<?xml version='1.0' encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en" xml:lang="en" xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <link href="cpip.css" rel="stylesheet" type="text/css" />
    <title>File: /Users/paulross/dev/Python-3.6.2/Include/object.h</title>
  </head>
  <body>
    <h1>File: /Users/paulross/dev/Python-3.6.2/Include/object.h</h1>
    <p>Green shading in the line number column
means the source is part of the translation unit, red means it is conditionally excluded.
Highlighted line numbers link to the translation unit page. Highlighted macros link to
the macro page.</p>
    <pre><a name="1" /><span class="Maybe">       1:</span> <span class="f">#</span><span class="n">ifndef</span> <a href="macros_ref.html#_UHlfT0JKRUNUX0hfMA__"><span class="b">Py_OBJECT_H</span></a>
<a name="2" /><span class="Maybe">       2:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfT0JKRUNUX0hfMA__"><span class="b">Py_OBJECT_H</span></a>
<a name="3" /><span class="False">       3:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">__cplusplus</span>
<a name="4" /><span class="False">       4:</span> <span class="m">extern</span> <span class="e">&quot;C&quot;</span> <span class="f">{</span>
<a name="5" /><span class="Maybe">       5:</span> <span class="f">#</span><span class="n">endif</span>
<a name="6" /><span class="Maybe">       6:</span> 
<a name="7" /><span class="Maybe">       7:</span> 
<a name="8" /><span class="Maybe">       8:</span> <span class="k">/* Object and type object interface */</span>
<a name="9" /><span class="Maybe">       9:</span> 
<a name="10" /><span class="Maybe">      10:</span> <span class="k">/*</span>
<a name="11" /><span class="Maybe">      11:</span> <span class="k">Objects are structures allocated on the heap.  Special rules apply to</span>
<a name="12" /><span class="Maybe">      12:</span> <span class="k">the use of objects to ensure they are properly garbage-collected.</span>
<a name="13" /><span class="Maybe">      13:</span> <span class="k">Objects are never allocated statically or on the stack; they must be</span>
<a name="14" /><span class="Maybe">      14:</span> <span class="k">accessed through special macros and functions only.  (Type objects are</span>
<a name="15" /><span class="Maybe">      15:</span> <span class="k">exceptions to the first rule; the standard types are represented by</span>
<a name="16" /><span class="Maybe">      16:</span> <span class="k">statically initialized type objects, although work on type/class unification</span>
<a name="17" /><span class="Maybe">      17:</span> <span class="k">for Python 2.2 made it possible to have heap-allocated type objects too).</span>
<a name="18" /><span class="Maybe">      18:</span> <span class="k"></span>
<a name="19" /><span class="Maybe">      19:</span> <span class="k">An object has a &apos;reference count&apos; that is increased or decreased when a</span>
<a name="20" /><span class="Maybe">      20:</span> <span class="k">pointer to the object is copied or deleted; when the reference count</span>
<a name="21" /><span class="Maybe">      21:</span> <span class="k">reaches zero there are no references to the object left and it can be</span>
<a name="22" /><span class="Maybe">      22:</span> <span class="k">removed from the heap.</span>
<a name="23" /><span class="Maybe">      23:</span> <span class="k"></span>
<a name="24" /><span class="Maybe">      24:</span> <span class="k">An object has a &apos;type&apos; that determines what it represents and what kind</span>
<a name="25" /><span class="Maybe">      25:</span> <span class="k">of data it contains.  An object&apos;s type is fixed when it is created.</span>
<a name="26" /><span class="Maybe">      26:</span> <span class="k">Types themselves are represented as objects; an object contains a</span>
<a name="27" /><span class="Maybe">      27:</span> <span class="k">pointer to the corresponding type object.  The type itself has a type</span>
<a name="28" /><span class="Maybe">      28:</span> <span class="k">pointer pointing to the object representing the type &apos;type&apos;, which</span>
<a name="29" /><span class="Maybe">      29:</span> <span class="k">contains a pointer to itself!).</span>
<a name="30" /><span class="Maybe">      30:</span> <span class="k"></span>
<a name="31" /><span class="Maybe">      31:</span> <span class="k">Objects do not float around in memory; once allocated an object keeps</span>
<a name="32" /><span class="Maybe">      32:</span> <span class="k">the same size and address.  Objects that must hold variable-size data</span>
<a name="33" /><span class="Maybe">      33:</span> <span class="k">can contain pointers to variable-size parts of the object.  Not all</span>
<a name="34" /><span class="Maybe">      34:</span> <span class="k">objects of the same type have the same size; but the size cannot change</span>
<a name="35" /><span class="Maybe">      35:</span> <span class="k">after allocation.  (These restrictions are made so a reference to an</span>
<a name="36" /><span class="Maybe">      36:</span> <span class="k">object can be simply a pointer -- moving an object would require</span>
<a name="37" /><span class="Maybe">      37:</span> <span class="k">updating all the pointers, and changing an object&apos;s size would require</span>
<a name="38" /><span class="Maybe">      38:</span> <span class="k">moving it if there was another object right next to it.)</span>
<a name="39" /><span class="Maybe">      39:</span> <span class="k"></span>
<a name="40" /><span class="Maybe">      40:</span> <span class="k">Objects are always accessed through pointers of the type &apos;PyObject *&apos;.</span>
<a name="41" /><span class="Maybe">      41:</span> <span class="k">The type &apos;PyObject&apos; is a structure that only contains the reference count</span>
<a name="42" /><span class="Maybe">      42:</span> <span class="k">and the type pointer.  The actual memory allocated for an object</span>
<a name="43" /><span class="Maybe">      43:</span> <span class="k">contains other data that can only be accessed after casting the pointer</span>
<a name="44" /><span class="Maybe">      44:</span> <span class="k">to a pointer to a longer structure type.  This longer type must start</span>
<a name="45" /><span class="Maybe">      45:</span> <span class="k">with the reference count and type fields; the macro PyObject_HEAD should be</span>
<a name="46" /><span class="Maybe">      46:</span> <span class="k">used for this (to accommodate for future changes).  The implementation</span>
<a name="47" /><span class="Maybe">      47:</span> <span class="k">of a particular object type can cast the object pointer to the proper</span>
<a name="48" /><span class="Maybe">      48:</span> <span class="k">type and back.</span>
<a name="49" /><span class="Maybe">      49:</span> <span class="k"></span>
<a name="50" /><span class="Maybe">      50:</span> <span class="k">A standard interface exists for objects that contain an array of items</span>
<a name="51" /><span class="Maybe">      51:</span> <span class="k">whose size is determined when the object is allocated.</span>
<a name="52" /><span class="Maybe">      52:</span> <span class="k">*/</span>
<a name="53" /><span class="Maybe">      53:</span> 
<a name="54" /><span class="Maybe">      54:</span> <span class="k">/* Py_DEBUG implies Py_TRACE_REFS. */</span>
<a name="55" /><span class="Maybe">      55:</span> <span class="f">#</span><span class="n">if</span> <span class="b">defined</span><span class="f">(</span><a href="macros_ref.html#_UHlfREVCVUdfMA__"><span class="b">Py_DEBUG</span></a><span class="f">)</span> <span class="f">&amp;&amp;</span> <span class="f">!</span><span class="b">defined</span><span class="f">(</span><a href="macros_ref.html#_UHlfVFJBQ0VfUkVGU18w"><span class="b">Py_TRACE_REFS</span></a><span class="f">)</span>
<a name="56" /><span class="Maybe">      56:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFJBQ0VfUkVGU18w"><span class="b">Py_TRACE_REFS</span></a>
<a name="57" /><span class="Maybe">      57:</span> <span class="f">#</span><span class="n">endif</span>
<a name="58" /><span class="Maybe">      58:</span> 
<a name="59" /><span class="Maybe">      59:</span> <span class="k">/* Py_TRACE_REFS implies Py_REF_DEBUG. */</span>
<a name="60" /><span class="Maybe">      60:</span> <span class="f">#</span><span class="n">if</span> <span class="b">defined</span><span class="f">(</span><a href="macros_ref.html#_UHlfVFJBQ0VfUkVGU18w"><span class="b">Py_TRACE_REFS</span></a><span class="f">)</span> <span class="f">&amp;&amp;</span> <span class="f">!</span><span class="b">defined</span><span class="f">(</span><a href="macros_ref.html#_UHlfUkVGX0RFQlVHXzA_"><span class="b">Py_REF_DEBUG</span></a><span class="f">)</span>
<a name="61" /><span class="Maybe">      61:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfUkVGX0RFQlVHXzA_"><span class="b">Py_REF_DEBUG</span></a>
<a name="62" /><span class="Maybe">      62:</span> <span class="f">#</span><span class="n">endif</span>
<a name="63" /><span class="Maybe">      63:</span> 
<a name="64" /><span class="False">      64:</span> <span class="f">#</span><span class="n">if</span> <span class="b">defined</span><span class="f">(</span><span class="b">Py_LIMITED_API</span><span class="f">)</span> <span class="f">&amp;&amp;</span> <span class="b">defined</span><span class="f">(</span><a href="macros_ref.html#_UHlfUkVGX0RFQlVHXzA_"><span class="b">Py_REF_DEBUG</span></a><span class="f">)</span>
<a name="65" /><span class="False">      65:</span> <span class="f">#</span><span class="n">error</span> <span class="b">Py_LIMITED_API</span> <span class="b">is</span> <span class="b">incompatible</span> <span class="b">with</span> <a href="macros_ref.html#_UHlfREVCVUdfMA__"><span class="b">Py_DEBUG</span></a><span class="f">,</span> <a href="macros_ref.html#_UHlfVFJBQ0VfUkVGU18w"><span class="b">Py_TRACE_REFS</span></a><span class="f">,</span> <span class="b">and</span> <a href="macros_ref.html#_UHlfUkVGX0RFQlVHXzA_"><span class="b">Py_REF_DEBUG</span></a>
<a name="66" /><span class="Maybe">      66:</span> <span class="f">#</span><span class="n">endif</span>
<a name="67" /><span class="Maybe">      67:</span> 
<a name="68" /><span class="Maybe">      68:</span> 
<a name="69" /><span class="Maybe">      69:</span> <span class="f">#</span><span class="n">ifdef</span> <a href="macros_ref.html#_UHlfVFJBQ0VfUkVGU18w"><span class="b">Py_TRACE_REFS</span></a>
<a name="70" /><span class="Maybe">      70:</span> <span class="k">/* Define pointers to support a doubly-linked list of all live heap objects. */</span>
<a name="71" /><span class="Maybe">      71:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5T2JqZWN0X0hFQURfRVhUUkFfMA__"><span class="b">_PyObject_HEAD_EXTRA</span></a>            \
<a name="72" /><span class="Maybe">      72:</span>     <span class="m">struct</span> <span class="b">_object</span> <span class="f">*</span><span class="b">_ob_next</span><span class="f">;</span>           \
<a name="73" /><span class="Maybe">      73:</span>     <span class="m">struct</span> <span class="b">_object</span> <span class="f">*</span><span class="b">_ob_prev</span><span class="f">;</span>
<a name="74" /><span class="Maybe">      74:</span> 
<a name="75" /><span class="Maybe">      75:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5T2JqZWN0X0VYVFJBX0lOSVRfMA__"><span class="b">_PyObject_EXTRA_INIT</span></a> <span class="c">0</span><span class="f">,</span> <span class="c">0</span><span class="f">,</span>
<a name="76" /><span class="Maybe">      76:</span> 
<a name="77" /><span class="False">      77:</span> <span class="f">#</span><span class="n">else</span>
<a name="78" /><span class="False">      78:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5T2JqZWN0X0hFQURfRVhUUkFfMA__"><span class="b">_PyObject_HEAD_EXTRA</span></a>
<a name="79" /><span class="False">      79:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5T2JqZWN0X0VYVFJBX0lOSVRfMA__"><span class="b">_PyObject_EXTRA_INIT</span></a>
<a name="80" /><span class="Maybe">      80:</span> <span class="f">#</span><span class="n">endif</span>
<a name="81" /><span class="Maybe">      81:</span> 
<a name="82" /><span class="Maybe">      82:</span> <span class="k">/* PyObject_HEAD defines the initial segment of every PyObject. */</span>
<a name="83" /><span class="Maybe">      83:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlPYmplY3RfSEVBRF8w"><span class="b">PyObject_HEAD</span></a>                   <span class="b">PyObject</span> <span class="b">ob_base</span><span class="f">;</span>
<a name="84" /><span class="Maybe">      84:</span> 
<a name="85" /><span class="Maybe">      85:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlPYmplY3RfSEVBRF9JTklUXzA_"><span class="b">PyObject_HEAD_INIT</span></a><span class="f">(</span><span class="b">type</span><span class="f">)</span>        \
<a name="86" /><span class="Maybe">      86:</span>     <span class="f">{</span> <a href="macros_ref.html#_X1B5T2JqZWN0X0VYVFJBX0lOSVRfMA__"><span class="b">_PyObject_EXTRA_INIT</span></a>              \
<a name="87" /><span class="Maybe">      87:</span>     <span class="c">1</span><span class="f">,</span> <span class="b">type</span> <span class="f">}</span><span class="f">,</span>
<a name="88" /><span class="Maybe">      88:</span> 
<a name="89" /><span class="Maybe">      89:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlWYXJPYmplY3RfSEVBRF9JTklUXzA_"><span class="b">PyVarObject_HEAD_INIT</span></a><span class="f">(</span><span class="b">type</span><span class="f">,</span> <span class="b">size</span><span class="f">)</span>       \
<a name="90" /><span class="Maybe">      90:</span>     <span class="f">{</span> <a href="macros_ref.html#_UHlPYmplY3RfSEVBRF9JTklUXzA_"><span class="b">PyObject_HEAD_INIT</span></a><span class="f">(</span><span class="b">type</span><span class="f">)</span> <span class="b">size</span> <span class="f">}</span><span class="f">,</span>
<a name="91" /><span class="Maybe">      91:</span> 
<a name="92" /><span class="Maybe">      92:</span> <span class="k">/* PyObject_VAR_HEAD defines the initial segment of all variable-size</span>
<a name="93" /><span class="Maybe">      93:</span> <span class="k"> * container objects.  These end with a declaration of an array with 1</span>
<a name="94" /><span class="Maybe">      94:</span> <span class="k"> * element, but enough space is malloc&apos;ed so that the array actually</span>
<a name="95" /><span class="Maybe">      95:</span> <span class="k"> * has room for ob_size elements.  Note that ob_size is an element count,</span>
<a name="96" /><span class="Maybe">      96:</span> <span class="k"> * not necessarily a byte count.</span>
<a name="97" /><span class="Maybe">      97:</span> <span class="k"> */</span>
<a name="98" /><span class="Maybe">      98:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlPYmplY3RfVkFSX0hFQURfMA__"><span class="b">PyObject_VAR_HEAD</span></a>      <span class="b">PyVarObject</span> <span class="b">ob_base</span><span class="f">;</span>
<a name="99" /><span class="Maybe">      99:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfSU5WQUxJRF9TSVpFXzA_"><span class="b">Py_INVALID_SIZE</span></a> <span class="f">(</span><span class="b">Py_ssize_t</span><span class="f">)</span><span class="f">-</span><span class="c">1</span>
<a name="100" /><span class="Maybe">     100:</span> 
<a name="101" /><span class="Maybe">     101:</span> <span class="k">/* Nothing is actually declared to be a PyObject, but every pointer to</span>
<a name="102" /><span class="Maybe">     102:</span> <span class="k"> * a Python object can be cast to a PyObject*.  This is inheritance built</span>
<a name="103" /><span class="Maybe">     103:</span> <span class="k"> * by hand.  Similarly every pointer to a variable-size Python object can,</span>
<a name="104" /><span class="Maybe">     104:</span> <span class="k"> * in addition, be cast to PyVarObject*.</span>
<a name="105" /><span class="Maybe">     105:</span> <span class="k"> */</span>
<a name="106" /><span class="Maybe">     106:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="b">_object</span> <span class="f">{</span>
<a name="107" /><span class="Maybe">     107:</span>     <a href="macros_ref.html#_X1B5T2JqZWN0X0hFQURfRVhUUkFfMA__"><span class="b">_PyObject_HEAD_EXTRA</span></a>
<a name="108" /><span class="Maybe">     108:</span>     <span class="b">Py_ssize_t</span> <span class="b">ob_refcnt</span><span class="f">;</span>
<a name="109" /><span class="Maybe">     109:</span>     <span class="m">struct</span> <span class="b">_typeobject</span> <span class="f">*</span><span class="b">ob_type</span><span class="f">;</span>
<a name="110" /><span class="Maybe">     110:</span> <span class="f">}</span> <span class="b">PyObject</span><span class="f">;</span>
<a name="111" /><span class="Maybe">     111:</span> 
<a name="112" /><span class="Maybe">     112:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="f">{</span>
<a name="113" /><span class="Maybe">     113:</span>     <span class="b">PyObject</span> <span class="b">ob_base</span><span class="f">;</span>
<a name="114" /><span class="Maybe">     114:</span>     <span class="b">Py_ssize_t</span> <span class="b">ob_size</span><span class="f">;</span> <span class="k">/* Number of items in variable part */</span>
<a name="115" /><span class="Maybe">     115:</span> <span class="f">}</span> <span class="b">PyVarObject</span><span class="f">;</span>
<a name="116" /><span class="Maybe">     116:</span> 
<a name="117" /><span class="Maybe">     117:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfUkVGQ05UXzA_"><span class="b">Py_REFCNT</span></a><span class="f">(</span><span class="b">ob</span><span class="f">)</span>           <span class="f">(</span><span class="f">(</span><span class="f">(</span><span class="b">PyObject</span><span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">ob</span><span class="f">)</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">ob_refcnt</span><span class="f">)</span>
<a name="118" /><span class="Maybe">     118:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">ob</span><span class="f">)</span>             <span class="f">(</span><span class="f">(</span><span class="f">(</span><span class="b">PyObject</span><span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">ob</span><span class="f">)</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">ob_type</span><span class="f">)</span>
<a name="119" /><span class="Maybe">     119:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfU0laRV8w"><span class="b">Py_SIZE</span></a><span class="f">(</span><span class="b">ob</span><span class="f">)</span>             <span class="f">(</span><span class="f">(</span><span class="f">(</span><span class="b">PyVarObject</span><span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">ob</span><span class="f">)</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">ob_size</span><span class="f">)</span>
<a name="120" /><span class="Maybe">     120:</span> 
<a name="121" /><span class="Maybe">     121:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="122" /><span class="Maybe">     122:</span> <span class="k">/********************* String Literals ****************************************/</span>
<a name="123" /><span class="Maybe">     123:</span> <span class="k">/* This structure helps managing static strings. The basic usage goes like this:</span>
<a name="124" /><span class="Maybe">     124:</span> <span class="k">   Instead of doing</span>
<a name="125" /><span class="Maybe">     125:</span> <span class="k"></span>
<a name="126" /><span class="Maybe">     126:</span> <span class="k">       r = PyObject_CallMethod(o, &quot;foo&quot;, &quot;args&quot;, ...);</span>
<a name="127" /><span class="Maybe">     127:</span> <span class="k"></span>
<a name="128" /><span class="Maybe">     128:</span> <span class="k">   do</span>
<a name="129" /><span class="Maybe">     129:</span> <span class="k"></span>
<a name="130" /><span class="Maybe">     130:</span> <span class="k">       _Py_IDENTIFIER(foo);</span>
<a name="131" /><span class="Maybe">     131:</span> <span class="k">       ...</span>
<a name="132" /><span class="Maybe">     132:</span> <span class="k">       r = _PyObject_CallMethodId(o, &amp;PyId_foo, &quot;args&quot;, ...);</span>
<a name="133" /><span class="Maybe">     133:</span> <span class="k"></span>
<a name="134" /><span class="Maybe">     134:</span> <span class="k">   PyId_foo is a static variable, either on block level or file level. On first</span>
<a name="135" /><span class="Maybe">     135:</span> <span class="k">   usage, the string &quot;foo&quot; is interned, and the structures are linked. On interpreter</span>
<a name="136" /><span class="Maybe">     136:</span> <span class="k">   shutdown, all strings are released (through _PyUnicode_ClearStaticStrings).</span>
<a name="137" /><span class="Maybe">     137:</span> <span class="k"></span>
<a name="138" /><span class="Maybe">     138:</span> <span class="k">   Alternatively, _Py_static_string allows choosing the variable name.</span>
<a name="139" /><span class="Maybe">     139:</span> <span class="k">   _PyUnicode_FromId returns a borrowed reference to the interned string.</span>
<a name="140" /><span class="Maybe">     140:</span> <span class="k">   _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*.</span>
<a name="141" /><span class="Maybe">     141:</span> <span class="k">*/</span>
<a name="142" /><span class="Maybe">     142:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="b">_Py_Identifier</span> <span class="f">{</span>
<a name="143" /><span class="Maybe">     143:</span>     <span class="m">struct</span> <span class="b">_Py_Identifier</span> <span class="f">*</span><span class="b">next</span><span class="f">;</span>
<a name="144" /><span class="Maybe">     144:</span>     <span class="m">const</span> <span class="m">char</span><span class="f">*</span> <span class="b">string</span><span class="f">;</span>
<a name="145" /><span class="Maybe">     145:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">object</span><span class="f">;</span>
<a name="146" /><span class="Maybe">     146:</span> <span class="f">}</span> <span class="b">_Py_Identifier</span><span class="f">;</span>
<a name="147" /><span class="Maybe">     147:</span> 
<a name="148" /><span class="Maybe">     148:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X3N0YXRpY19zdHJpbmdfaW5pdF8w"><span class="b">_Py_static_string_init</span></a><span class="f">(</span><span class="b">value</span><span class="f">)</span> <span class="f">{</span> <span class="f">.</span><span class="b">next</span> <span class="f">=</span> <a href="macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">,</span> <span class="f">.</span><span class="b">string</span> <span class="f">=</span> <span class="b">value</span><span class="f">,</span> <span class="f">.</span><span class="b">object</span> <span class="f">=</span> <a href="macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a> <span class="f">}</span>
<a name="149" /><span class="Maybe">     149:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X3N0YXRpY19zdHJpbmdfMA__"><span class="b">_Py_static_string</span></a><span class="f">(</span><span class="b">varname</span><span class="f">,</span> <span class="b">value</span><span class="f">)</span>  <span class="m">static</span> <span class="b">_Py_Identifier</span> <span class="b">varname</span> <span class="f">=</span> <a href="macros_ref.html#_X1B5X3N0YXRpY19zdHJpbmdfaW5pdF8w"><span class="b">_Py_static_string_init</span></a><span class="f">(</span><span class="b">value</span><span class="f">)</span>
<a name="150" /><span class="Maybe">     150:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X0lERU5USUZJRVJfMA__"><span class="b">_Py_IDENTIFIER</span></a><span class="f">(</span><span class="b">varname</span><span class="f">)</span> <a href="macros_ref.html#_X1B5X3N0YXRpY19zdHJpbmdfMA__"><span class="b">_Py_static_string</span></a><span class="f">(</span><span class="b">PyId_</span><span class="f">##</span><span class="b">varname</span><span class="f">,</span> <span class="f">#</span><span class="b">varname</span><span class="f">)</span>
<a name="151" /><span class="Maybe">     151:</span> 
<a name="152" /><span class="Maybe">     152:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* !Py_LIMITED_API */</span>
<a name="153" /><span class="Maybe">     153:</span> 
<a name="154" /><span class="Maybe">     154:</span> <span class="k">/*</span>
<a name="155" /><span class="Maybe">     155:</span> <span class="k">Type objects contain a string containing the type name (to help somewhat</span>
<a name="156" /><span class="Maybe">     156:</span> <span class="k">in debugging), the allocation parameters (see PyObject_New() and</span>
<a name="157" /><span class="Maybe">     157:</span> <span class="k">PyObject_NewVar()),</span>
<a name="158" /><span class="Maybe">     158:</span> <span class="k">and methods for accessing objects of the type.  Methods are optional, a</span>
<a name="159" /><span class="Maybe">     159:</span> <span class="k">nil pointer meaning that particular kind of access is not available for</span>
<a name="160" /><span class="Maybe">     160:</span> <span class="k">this type.  The Py_DECREF() macro uses the tp_dealloc method without</span>
<a name="161" /><span class="Maybe">     161:</span> <span class="k">checking for a nil pointer; it should always be implemented except if</span>
<a name="162" /><span class="Maybe">     162:</span> <span class="k">the implementation can guarantee that the reference count will never</span>
<a name="163" /><span class="Maybe">     163:</span> <span class="k">reach zero (e.g., for statically allocated type objects).</span>
<a name="164" /><span class="Maybe">     164:</span> <span class="k"></span>
<a name="165" /><span class="Maybe">     165:</span> <span class="k">NB: the methods for certain type groups are now contained in separate</span>
<a name="166" /><span class="Maybe">     166:</span> <span class="k">method blocks.</span>
<a name="167" /><span class="Maybe">     167:</span> <span class="k">*/</span>
<a name="168" /><span class="Maybe">     168:</span> 
<a name="169" /><span class="Maybe">     169:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span> <span class="f">(</span><span class="f">*</span><span class="b">unaryfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="170" /><span class="Maybe">     170:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span> <span class="f">(</span><span class="f">*</span><span class="b">binaryfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="171" /><span class="Maybe">     171:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span> <span class="f">(</span><span class="f">*</span><span class="b">ternaryfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="172" /><span class="Maybe">     172:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">inquiry</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="173" /><span class="Maybe">     173:</span> <span class="m">typedef</span> <span class="b">Py_ssize_t</span> <span class="f">(</span><span class="f">*</span><span class="b">lenfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="174" /><span class="Maybe">     174:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">ssizeargfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">Py_ssize_t</span><span class="f">)</span><span class="f">;</span>
<a name="175" /><span class="Maybe">     175:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">ssizessizeargfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">Py_ssize_t</span><span class="f">,</span> <span class="b">Py_ssize_t</span><span class="f">)</span><span class="f">;</span>
<a name="176" /><span class="Maybe">     176:</span> <span class="m">typedef</span> <span class="m">int</span><span class="f">(</span><span class="f">*</span><span class="b">ssizeobjargproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">Py_ssize_t</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="177" /><span class="Maybe">     177:</span> <span class="m">typedef</span> <span class="m">int</span><span class="f">(</span><span class="f">*</span><span class="b">ssizessizeobjargproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">Py_ssize_t</span><span class="f">,</span> <span class="b">Py_ssize_t</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="178" /><span class="Maybe">     178:</span> <span class="m">typedef</span> <span class="m">int</span><span class="f">(</span><span class="f">*</span><span class="b">objobjargproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="179" /><span class="Maybe">     179:</span> 
<a name="180" /><span class="Maybe">     180:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="181" /><span class="Maybe">     181:</span> <span class="k">/* buffer interface */</span>
<a name="182" /><span class="Maybe">     182:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="b">bufferinfo</span> <span class="f">{</span>
<a name="183" /><span class="Maybe">     183:</span>     <span class="m">void</span> <span class="f">*</span><span class="b">buf</span><span class="f">;</span>
<a name="184" /><span class="Maybe">     184:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">obj</span><span class="f">;</span>        <span class="k">/* owned reference */</span>
<a name="185" /><span class="Maybe">     185:</span>     <span class="b">Py_ssize_t</span> <span class="b">len</span><span class="f">;</span>
<a name="186" /><span class="Maybe">     186:</span>     <span class="b">Py_ssize_t</span> <span class="b">itemsize</span><span class="f">;</span>  <span class="k">/* This is Py_ssize_t so it can be</span>
<a name="187" /><span class="Maybe">     187:</span> <span class="k">                             pointed to by strides in simple case.*/</span>
<a name="188" /><span class="Maybe">     188:</span>     <span class="m">int</span> <span class="b">readonly</span><span class="f">;</span>
<a name="189" /><span class="Maybe">     189:</span>     <span class="m">int</span> <span class="b">ndim</span><span class="f">;</span>
<a name="190" /><span class="Maybe">     190:</span>     <span class="m">char</span> <span class="f">*</span><span class="b">format</span><span class="f">;</span>
<a name="191" /><span class="Maybe">     191:</span>     <span class="b">Py_ssize_t</span> <span class="f">*</span><span class="b">shape</span><span class="f">;</span>
<a name="192" /><span class="Maybe">     192:</span>     <span class="b">Py_ssize_t</span> <span class="f">*</span><span class="b">strides</span><span class="f">;</span>
<a name="193" /><span class="Maybe">     193:</span>     <span class="b">Py_ssize_t</span> <span class="f">*</span><span class="b">suboffsets</span><span class="f">;</span>
<a name="194" /><span class="Maybe">     194:</span>     <span class="m">void</span> <span class="f">*</span><span class="b">internal</span><span class="f">;</span>
<a name="195" /><span class="Maybe">     195:</span> <span class="f">}</span> <span class="b">Py_buffer</span><span class="f">;</span>
<a name="196" /><span class="Maybe">     196:</span> 
<a name="197" /><span class="Maybe">     197:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">getbufferproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">Py_buffer</span> <span class="f">*</span><span class="f">,</span> <span class="m">int</span><span class="f">)</span><span class="f">;</span>
<a name="198" /><span class="Maybe">     198:</span> <span class="m">typedef</span> <span class="m">void</span> <span class="f">(</span><span class="f">*</span><span class="b">releasebufferproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">Py_buffer</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="199" /><span class="Maybe">     199:</span> 
<a name="200" /><span class="Maybe">     200:</span> <span class="k">/* Maximum number of dimensions */</span>
<a name="201" /><span class="Maybe">     201:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfTUFYX05ESU1fMA__"><span class="b">PyBUF_MAX_NDIM</span></a> <span class="c">64</span>
<a name="202" /><span class="Maybe">     202:</span> 
<a name="203" /><span class="Maybe">     203:</span> <span class="k">/* Flags for getting buffers */</span>
<a name="204" /><span class="Maybe">     204:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfU0lNUExFXzA_"><span class="b">PyBUF_SIMPLE</span></a> <span class="c">0</span>
<a name="205" /><span class="Maybe">     205:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfV1JJVEFCTEVfMA__"><span class="b">PyBUF_WRITABLE</span></a> <span class="c">0x0001</span>
<a name="206" /><span class="Maybe">     206:</span> <span class="k">/*  we used to include an E, backwards compatible alias  */</span>
<a name="207" /><span class="Maybe">     207:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfV1JJVEVBQkxFXzA_"><span class="b">PyBUF_WRITEABLE</span></a> <a href="macros_noref.html#_UHlCVUZfV1JJVEFCTEVfMA__"><span class="b">PyBUF_WRITABLE</span></a>
<a name="208" /><span class="Maybe">     208:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfRk9STUFUXzA_"><span class="b">PyBUF_FORMAT</span></a> <span class="c">0x0004</span>
<a name="209" /><span class="Maybe">     209:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfTkRfMA__"><span class="b">PyBUF_ND</span></a> <span class="c">0x0008</span>
<a name="210" /><span class="Maybe">     210:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a> <span class="f">(</span><span class="c">0x0010</span> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfTkRfMA__"><span class="b">PyBUF_ND</span></a><span class="f">)</span>
<a name="211" /><span class="Maybe">     211:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfQ19DT05USUdVT1VTXzA_"><span class="b">PyBUF_C_CONTIGUOUS</span></a> <span class="f">(</span><span class="c">0x0020</span> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a><span class="f">)</span>
<a name="212" /><span class="Maybe">     212:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfRl9DT05USUdVT1VTXzA_"><span class="b">PyBUF_F_CONTIGUOUS</span></a> <span class="f">(</span><span class="c">0x0040</span> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a><span class="f">)</span>
<a name="213" /><span class="Maybe">     213:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfQU5ZX0NPTlRJR1VPVVNfMA__"><span class="b">PyBUF_ANY_CONTIGUOUS</span></a> <span class="f">(</span><span class="c">0x0080</span> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a><span class="f">)</span>
<a name="214" /><span class="Maybe">     214:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfSU5ESVJFQ1RfMA__"><span class="b">PyBUF_INDIRECT</span></a> <span class="f">(</span><span class="c">0x0100</span> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a><span class="f">)</span>
<a name="215" /><span class="Maybe">     215:</span> 
<a name="216" /><span class="Maybe">     216:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfQ09OVElHXzA_"><span class="b">PyBUF_CONTIG</span></a> <span class="f">(</span><a href="macros_noref.html#_UHlCVUZfTkRfMA__"><span class="b">PyBUF_ND</span></a> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfV1JJVEFCTEVfMA__"><span class="b">PyBUF_WRITABLE</span></a><span class="f">)</span>
<a name="217" /><span class="Maybe">     217:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfQ09OVElHX1JPXzA_"><span class="b">PyBUF_CONTIG_RO</span></a> <span class="f">(</span><a href="macros_noref.html#_UHlCVUZfTkRfMA__"><span class="b">PyBUF_ND</span></a><span class="f">)</span>
<a name="218" /><span class="Maybe">     218:</span> 
<a name="219" /><span class="Maybe">     219:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfU1RSSURFRF8w"><span class="b">PyBUF_STRIDED</span></a> <span class="f">(</span><a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfV1JJVEFCTEVfMA__"><span class="b">PyBUF_WRITABLE</span></a><span class="f">)</span>
<a name="220" /><span class="Maybe">     220:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfU1RSSURFRF9ST18w"><span class="b">PyBUF_STRIDED_RO</span></a> <span class="f">(</span><a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a><span class="f">)</span>
<a name="221" /><span class="Maybe">     221:</span> 
<a name="222" /><span class="Maybe">     222:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfUkVDT1JEU18w"><span class="b">PyBUF_RECORDS</span></a> <span class="f">(</span><a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfV1JJVEFCTEVfMA__"><span class="b">PyBUF_WRITABLE</span></a> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfRk9STUFUXzA_"><span class="b">PyBUF_FORMAT</span></a><span class="f">)</span>
<a name="223" /><span class="Maybe">     223:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfUkVDT1JEU19ST18w"><span class="b">PyBUF_RECORDS_RO</span></a> <span class="f">(</span><a href="macros_noref.html#_UHlCVUZfU1RSSURFU18w"><span class="b">PyBUF_STRIDES</span></a> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfRk9STUFUXzA_"><span class="b">PyBUF_FORMAT</span></a><span class="f">)</span>
<a name="224" /><span class="Maybe">     224:</span> 
<a name="225" /><span class="Maybe">     225:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfRlVMTF8w"><span class="b">PyBUF_FULL</span></a> <span class="f">(</span><a href="macros_noref.html#_UHlCVUZfSU5ESVJFQ1RfMA__"><span class="b">PyBUF_INDIRECT</span></a> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfV1JJVEFCTEVfMA__"><span class="b">PyBUF_WRITABLE</span></a> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfRk9STUFUXzA_"><span class="b">PyBUF_FORMAT</span></a><span class="f">)</span>
<a name="226" /><span class="Maybe">     226:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfRlVMTF9ST18w"><span class="b">PyBUF_FULL_RO</span></a> <span class="f">(</span><a href="macros_noref.html#_UHlCVUZfSU5ESVJFQ1RfMA__"><span class="b">PyBUF_INDIRECT</span></a> <span class="f">|</span> <a href="macros_noref.html#_UHlCVUZfRk9STUFUXzA_"><span class="b">PyBUF_FORMAT</span></a><span class="f">)</span>
<a name="227" /><span class="Maybe">     227:</span> 
<a name="228" /><span class="Maybe">     228:</span> 
<a name="229" /><span class="Maybe">     229:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfUkVBRF8w"><span class="b">PyBUF_READ</span></a>  <span class="c">0x100</span>
<a name="230" /><span class="Maybe">     230:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlCVUZfV1JJVEVfMA__"><span class="b">PyBUF_WRITE</span></a> <span class="c">0x200</span>
<a name="231" /><span class="Maybe">     231:</span> 
<a name="232" /><span class="Maybe">     232:</span> <span class="k">/* End buffer interface */</span>
<a name="233" /><span class="Maybe">     233:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* Py_LIMITED_API */</span>
<a name="234" /><span class="Maybe">     234:</span> 
<a name="235" /><span class="Maybe">     235:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">objobjproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="236" /><span class="Maybe">     236:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">visitproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="237" /><span class="Maybe">     237:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">traverseproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">visitproc</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="238" /><span class="Maybe">     238:</span> 
<a name="239" /><span class="Maybe">     239:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="240" /><span class="Maybe">     240:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="f">{</span>
<a name="241" /><span class="Maybe">     241:</span>     <span class="k">/* Number implementations must check *both*</span>
<a name="242" /><span class="Maybe">     242:</span> <span class="k">       arguments for proper type and implement the necessary conversions</span>
<a name="243" /><span class="Maybe">     243:</span> <span class="k">       in the slot functions themselves. */</span>
<a name="244" /><span class="Maybe">     244:</span> 
<a name="245" /><span class="Maybe">     245:</span>     <span class="b">binaryfunc</span> <span class="b">nb_add</span><span class="f">;</span>
<a name="246" /><span class="Maybe">     246:</span>     <span class="b">binaryfunc</span> <span class="b">nb_subtract</span><span class="f">;</span>
<a name="247" /><span class="Maybe">     247:</span>     <span class="b">binaryfunc</span> <span class="b">nb_multiply</span><span class="f">;</span>
<a name="248" /><span class="Maybe">     248:</span>     <span class="b">binaryfunc</span> <span class="b">nb_remainder</span><span class="f">;</span>
<a name="249" /><span class="Maybe">     249:</span>     <span class="b">binaryfunc</span> <span class="b">nb_divmod</span><span class="f">;</span>
<a name="250" /><span class="Maybe">     250:</span>     <span class="b">ternaryfunc</span> <span class="b">nb_power</span><span class="f">;</span>
<a name="251" /><span class="Maybe">     251:</span>     <span class="b">unaryfunc</span> <span class="b">nb_negative</span><span class="f">;</span>
<a name="252" /><span class="Maybe">     252:</span>     <span class="b">unaryfunc</span> <span class="b">nb_positive</span><span class="f">;</span>
<a name="253" /><span class="Maybe">     253:</span>     <span class="b">unaryfunc</span> <span class="b">nb_absolute</span><span class="f">;</span>
<a name="254" /><span class="Maybe">     254:</span>     <span class="b">inquiry</span> <span class="b">nb_bool</span><span class="f">;</span>
<a name="255" /><span class="Maybe">     255:</span>     <span class="b">unaryfunc</span> <span class="b">nb_invert</span><span class="f">;</span>
<a name="256" /><span class="Maybe">     256:</span>     <span class="b">binaryfunc</span> <span class="b">nb_lshift</span><span class="f">;</span>
<a name="257" /><span class="Maybe">     257:</span>     <span class="b">binaryfunc</span> <span class="b">nb_rshift</span><span class="f">;</span>
<a name="258" /><span class="Maybe">     258:</span>     <span class="b">binaryfunc</span> <span class="b">nb_and</span><span class="f">;</span>
<a name="259" /><span class="Maybe">     259:</span>     <span class="b">binaryfunc</span> <span class="b">nb_xor</span><span class="f">;</span>
<a name="260" /><span class="Maybe">     260:</span>     <span class="b">binaryfunc</span> <span class="b">nb_or</span><span class="f">;</span>
<a name="261" /><span class="Maybe">     261:</span>     <span class="b">unaryfunc</span> <span class="b">nb_int</span><span class="f">;</span>
<a name="262" /><span class="Maybe">     262:</span>     <span class="m">void</span> <span class="f">*</span><span class="b">nb_reserved</span><span class="f">;</span>  <span class="k">/* the slot formerly known as nb_long */</span>
<a name="263" /><span class="Maybe">     263:</span>     <span class="b">unaryfunc</span> <span class="b">nb_float</span><span class="f">;</span>
<a name="264" /><span class="Maybe">     264:</span> 
<a name="265" /><span class="Maybe">     265:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_add</span><span class="f">;</span>
<a name="266" /><span class="Maybe">     266:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_subtract</span><span class="f">;</span>
<a name="267" /><span class="Maybe">     267:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_multiply</span><span class="f">;</span>
<a name="268" /><span class="Maybe">     268:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_remainder</span><span class="f">;</span>
<a name="269" /><span class="Maybe">     269:</span>     <span class="b">ternaryfunc</span> <span class="b">nb_inplace_power</span><span class="f">;</span>
<a name="270" /><span class="Maybe">     270:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_lshift</span><span class="f">;</span>
<a name="271" /><span class="Maybe">     271:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_rshift</span><span class="f">;</span>
<a name="272" /><span class="Maybe">     272:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_and</span><span class="f">;</span>
<a name="273" /><span class="Maybe">     273:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_xor</span><span class="f">;</span>
<a name="274" /><span class="Maybe">     274:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_or</span><span class="f">;</span>
<a name="275" /><span class="Maybe">     275:</span> 
<a name="276" /><span class="Maybe">     276:</span>     <span class="b">binaryfunc</span> <span class="b">nb_floor_divide</span><span class="f">;</span>
<a name="277" /><span class="Maybe">     277:</span>     <span class="b">binaryfunc</span> <span class="b">nb_true_divide</span><span class="f">;</span>
<a name="278" /><span class="Maybe">     278:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_floor_divide</span><span class="f">;</span>
<a name="279" /><span class="Maybe">     279:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_true_divide</span><span class="f">;</span>
<a name="280" /><span class="Maybe">     280:</span> 
<a name="281" /><span class="Maybe">     281:</span>     <span class="b">unaryfunc</span> <span class="b">nb_index</span><span class="f">;</span>
<a name="282" /><span class="Maybe">     282:</span> 
<a name="283" /><span class="Maybe">     283:</span>     <span class="b">binaryfunc</span> <span class="b">nb_matrix_multiply</span><span class="f">;</span>
<a name="284" /><span class="Maybe">     284:</span>     <span class="b">binaryfunc</span> <span class="b">nb_inplace_matrix_multiply</span><span class="f">;</span>
<a name="285" /><span class="Maybe">     285:</span> <span class="f">}</span> <span class="b">PyNumberMethods</span><span class="f">;</span>
<a name="286" /><span class="Maybe">     286:</span> 
<a name="287" /><span class="Maybe">     287:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="f">{</span>
<a name="288" /><span class="Maybe">     288:</span>     <span class="b">lenfunc</span> <span class="b">sq_length</span><span class="f">;</span>
<a name="289" /><span class="Maybe">     289:</span>     <span class="b">binaryfunc</span> <span class="b">sq_concat</span><span class="f">;</span>
<a name="290" /><span class="Maybe">     290:</span>     <span class="b">ssizeargfunc</span> <span class="b">sq_repeat</span><span class="f">;</span>
<a name="291" /><span class="Maybe">     291:</span>     <span class="b">ssizeargfunc</span> <span class="b">sq_item</span><span class="f">;</span>
<a name="292" /><span class="Maybe">     292:</span>     <span class="m">void</span> <span class="f">*</span><span class="b">was_sq_slice</span><span class="f">;</span>
<a name="293" /><span class="Maybe">     293:</span>     <span class="b">ssizeobjargproc</span> <span class="b">sq_ass_item</span><span class="f">;</span>
<a name="294" /><span class="Maybe">     294:</span>     <span class="m">void</span> <span class="f">*</span><span class="b">was_sq_ass_slice</span><span class="f">;</span>
<a name="295" /><span class="Maybe">     295:</span>     <span class="b">objobjproc</span> <span class="b">sq_contains</span><span class="f">;</span>
<a name="296" /><span class="Maybe">     296:</span> 
<a name="297" /><span class="Maybe">     297:</span>     <span class="b">binaryfunc</span> <span class="b">sq_inplace_concat</span><span class="f">;</span>
<a name="298" /><span class="Maybe">     298:</span>     <span class="b">ssizeargfunc</span> <span class="b">sq_inplace_repeat</span><span class="f">;</span>
<a name="299" /><span class="Maybe">     299:</span> <span class="f">}</span> <span class="b">PySequenceMethods</span><span class="f">;</span>
<a name="300" /><span class="Maybe">     300:</span> 
<a name="301" /><span class="Maybe">     301:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="f">{</span>
<a name="302" /><span class="Maybe">     302:</span>     <span class="b">lenfunc</span> <span class="b">mp_length</span><span class="f">;</span>
<a name="303" /><span class="Maybe">     303:</span>     <span class="b">binaryfunc</span> <span class="b">mp_subscript</span><span class="f">;</span>
<a name="304" /><span class="Maybe">     304:</span>     <span class="b">objobjargproc</span> <span class="b">mp_ass_subscript</span><span class="f">;</span>
<a name="305" /><span class="Maybe">     305:</span> <span class="f">}</span> <span class="b">PyMappingMethods</span><span class="f">;</span>
<a name="306" /><span class="Maybe">     306:</span> 
<a name="307" /><span class="Maybe">     307:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="f">{</span>
<a name="308" /><span class="Maybe">     308:</span>     <span class="b">unaryfunc</span> <span class="b">am_await</span><span class="f">;</span>
<a name="309" /><span class="Maybe">     309:</span>     <span class="b">unaryfunc</span> <span class="b">am_aiter</span><span class="f">;</span>
<a name="310" /><span class="Maybe">     310:</span>     <span class="b">unaryfunc</span> <span class="b">am_anext</span><span class="f">;</span>
<a name="311" /><span class="Maybe">     311:</span> <span class="f">}</span> <span class="b">PyAsyncMethods</span><span class="f">;</span>
<a name="312" /><span class="Maybe">     312:</span> 
<a name="313" /><span class="Maybe">     313:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="f">{</span>
<a name="314" /><span class="Maybe">     314:</span>      <span class="b">getbufferproc</span> <span class="b">bf_getbuffer</span><span class="f">;</span>
<a name="315" /><span class="Maybe">     315:</span>      <span class="b">releasebufferproc</span> <span class="b">bf_releasebuffer</span><span class="f">;</span>
<a name="316" /><span class="Maybe">     316:</span> <span class="f">}</span> <span class="b">PyBufferProcs</span><span class="f">;</span>
<a name="317" /><span class="Maybe">     317:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* Py_LIMITED_API */</span>
<a name="318" /><span class="Maybe">     318:</span> 
<a name="319" /><span class="Maybe">     319:</span> <span class="m">typedef</span> <span class="m">void</span> <span class="f">(</span><span class="f">*</span><span class="b">freefunc</span><span class="f">)</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="320" /><span class="Maybe">     320:</span> <span class="m">typedef</span> <span class="m">void</span> <span class="f">(</span><span class="f">*</span><span class="b">destructor</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="321" /><span class="Maybe">     321:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="322" /><span class="Maybe">     322:</span> <span class="k">/* We can&apos;t provide a full compile-time check that limited-API</span>
<a name="323" /><span class="Maybe">     323:</span> <span class="k">   users won&apos;t implement tp_print. However, not defining printfunc</span>
<a name="324" /><span class="Maybe">     324:</span> <span class="k">   and making tp_print of a different function pointer type</span>
<a name="325" /><span class="Maybe">     325:</span> <span class="k">   should at least cause a warning in most cases. */</span>
<a name="326" /><span class="Maybe">     326:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">printfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">FILE</span> <span class="f">*</span><span class="f">,</span> <span class="m">int</span><span class="f">)</span><span class="f">;</span>
<a name="327" /><span class="Maybe">     327:</span> <span class="f">#</span><span class="n">endif</span>
<a name="328" /><span class="Maybe">     328:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">getattrfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">char</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="329" /><span class="Maybe">     329:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">getattrofunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="330" /><span class="Maybe">     330:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">setattrfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">char</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="331" /><span class="Maybe">     331:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">setattrofunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="332" /><span class="Maybe">     332:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">reprfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="333" /><span class="Maybe">     333:</span> <span class="m">typedef</span> <span class="b">Py_hash_t</span> <span class="f">(</span><span class="f">*</span><span class="b">hashfunc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="334" /><span class="Maybe">     334:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">richcmpfunc</span><span class="f">)</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">int</span><span class="f">)</span><span class="f">;</span>
<a name="335" /><span class="Maybe">     335:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">getiterfunc</span><span class="f">)</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="336" /><span class="Maybe">     336:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">iternextfunc</span><span class="f">)</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="337" /><span class="Maybe">     337:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">descrgetfunc</span><span class="f">)</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="338" /><span class="Maybe">     338:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">descrsetfunc</span><span class="f">)</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="339" /><span class="Maybe">     339:</span> <span class="m">typedef</span> <span class="m">int</span> <span class="f">(</span><span class="f">*</span><span class="b">initproc</span><span class="f">)</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="340" /><span class="Maybe">     340:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">newfunc</span><span class="f">)</span><span class="f">(</span><span class="m">struct</span> <span class="b">_typeobject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="341" /><span class="Maybe">     341:</span> <span class="m">typedef</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">(</span><span class="f">*</span><span class="b">allocfunc</span><span class="f">)</span><span class="f">(</span><span class="m">struct</span> <span class="b">_typeobject</span> <span class="f">*</span><span class="f">,</span> <span class="b">Py_ssize_t</span><span class="f">)</span><span class="f">;</span>
<a name="342" /><span class="Maybe">     342:</span> 
<a name="343" /><span class="False">     343:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">Py_LIMITED_API</span>
<a name="344" /><span class="False">     344:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="b">_typeobject</span> <span class="b">PyTypeObject</span><span class="f">;</span> <span class="k">/* opaque */</span>
<a name="345" /><span class="Maybe">     345:</span> <span class="f">#</span><span class="n">else</span>
<a name="346" /><span class="Maybe">     346:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="b">_typeobject</span> <span class="f">{</span>
<a name="347" /><span class="Maybe">     347:</span>     <a href="macros_ref.html#_UHlPYmplY3RfVkFSX0hFQURfMA__"><span class="b">PyObject_VAR_HEAD</span></a>
<a name="348" /><span class="Maybe">     348:</span>     <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="b">tp_name</span><span class="f">;</span> <span class="k">/* For printing, in format &quot;&lt;module&gt;.&lt;name&gt;&quot; */</span>
<a name="349" /><span class="Maybe">     349:</span>     <span class="b">Py_ssize_t</span> <span class="b">tp_basicsize</span><span class="f">,</span> <span class="b">tp_itemsize</span><span class="f">;</span> <span class="k">/* For allocation */</span>
<a name="350" /><span class="Maybe">     350:</span> 
<a name="351" /><span class="Maybe">     351:</span>     <span class="k">/* Methods to implement standard operations */</span>
<a name="352" /><span class="Maybe">     352:</span> 
<a name="353" /><span class="Maybe">     353:</span>     <span class="b">destructor</span> <span class="b">tp_dealloc</span><span class="f">;</span>
<a name="354" /><span class="Maybe">     354:</span>     <span class="b">printfunc</span> <span class="b">tp_print</span><span class="f">;</span>
<a name="355" /><span class="Maybe">     355:</span>     <span class="b">getattrfunc</span> <span class="b">tp_getattr</span><span class="f">;</span>
<a name="356" /><span class="Maybe">     356:</span>     <span class="b">setattrfunc</span> <span class="b">tp_setattr</span><span class="f">;</span>
<a name="357" /><span class="Maybe">     357:</span>     <span class="b">PyAsyncMethods</span> <span class="f">*</span><span class="b">tp_as_async</span><span class="f">;</span> <span class="k">/* formerly known as tp_compare (Python 2)</span>
<a name="358" /><span class="Maybe">     358:</span> <span class="k">                                    or tp_reserved (Python 3) */</span>
<a name="359" /><span class="Maybe">     359:</span>     <span class="b">reprfunc</span> <span class="b">tp_repr</span><span class="f">;</span>
<a name="360" /><span class="Maybe">     360:</span> 
<a name="361" /><span class="Maybe">     361:</span>     <span class="k">/* Method suites for standard classes */</span>
<a name="362" /><span class="Maybe">     362:</span> 
<a name="363" /><span class="Maybe">     363:</span>     <span class="b">PyNumberMethods</span> <span class="f">*</span><span class="b">tp_as_number</span><span class="f">;</span>
<a name="364" /><span class="Maybe">     364:</span>     <span class="b">PySequenceMethods</span> <span class="f">*</span><span class="b">tp_as_sequence</span><span class="f">;</span>
<a name="365" /><span class="Maybe">     365:</span>     <span class="b">PyMappingMethods</span> <span class="f">*</span><span class="b">tp_as_mapping</span><span class="f">;</span>
<a name="366" /><span class="Maybe">     366:</span> 
<a name="367" /><span class="Maybe">     367:</span>     <span class="k">/* More standard operations (here for binary compatibility) */</span>
<a name="368" /><span class="Maybe">     368:</span> 
<a name="369" /><span class="Maybe">     369:</span>     <span class="b">hashfunc</span> <span class="b">tp_hash</span><span class="f">;</span>
<a name="370" /><span class="Maybe">     370:</span>     <span class="b">ternaryfunc</span> <span class="b">tp_call</span><span class="f">;</span>
<a name="371" /><span class="Maybe">     371:</span>     <span class="b">reprfunc</span> <span class="b">tp_str</span><span class="f">;</span>
<a name="372" /><span class="Maybe">     372:</span>     <span class="b">getattrofunc</span> <span class="b">tp_getattro</span><span class="f">;</span>
<a name="373" /><span class="Maybe">     373:</span>     <span class="b">setattrofunc</span> <span class="b">tp_setattro</span><span class="f">;</span>
<a name="374" /><span class="Maybe">     374:</span> 
<a name="375" /><span class="Maybe">     375:</span>     <span class="k">/* Functions to access object as input/output buffer */</span>
<a name="376" /><span class="Maybe">     376:</span>     <span class="b">PyBufferProcs</span> <span class="f">*</span><span class="b">tp_as_buffer</span><span class="f">;</span>
<a name="377" /><span class="Maybe">     377:</span> 
<a name="378" /><span class="Maybe">     378:</span>     <span class="k">/* Flags to define presence of optional/expanded features */</span>
<a name="379" /><span class="Maybe">     379:</span>     <span class="m">unsigned</span> <span class="m">long</span> <span class="b">tp_flags</span><span class="f">;</span>
<a name="380" /><span class="Maybe">     380:</span> 
<a name="381" /><span class="Maybe">     381:</span>     <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="b">tp_doc</span><span class="f">;</span> <span class="k">/* Documentation string */</span>
<a name="382" /><span class="Maybe">     382:</span> 
<a name="383" /><span class="Maybe">     383:</span>     <span class="k">/* Assigned meaning in release 2.0 */</span>
<a name="384" /><span class="Maybe">     384:</span>     <span class="k">/* call function for all accessible objects */</span>
<a name="385" /><span class="Maybe">     385:</span>     <span class="b">traverseproc</span> <span class="b">tp_traverse</span><span class="f">;</span>
<a name="386" /><span class="Maybe">     386:</span> 
<a name="387" /><span class="Maybe">     387:</span>     <span class="k">/* delete references to contained objects */</span>
<a name="388" /><span class="Maybe">     388:</span>     <span class="b">inquiry</span> <span class="b">tp_clear</span><span class="f">;</span>
<a name="389" /><span class="Maybe">     389:</span> 
<a name="390" /><span class="Maybe">     390:</span>     <span class="k">/* Assigned meaning in release 2.1 */</span>
<a name="391" /><span class="Maybe">     391:</span>     <span class="k">/* rich comparisons */</span>
<a name="392" /><span class="Maybe">     392:</span>     <span class="b">richcmpfunc</span> <span class="b">tp_richcompare</span><span class="f">;</span>
<a name="393" /><span class="Maybe">     393:</span> 
<a name="394" /><span class="Maybe">     394:</span>     <span class="k">/* weak reference enabler */</span>
<a name="395" /><span class="Maybe">     395:</span>     <span class="b">Py_ssize_t</span> <span class="b">tp_weaklistoffset</span><span class="f">;</span>
<a name="396" /><span class="Maybe">     396:</span> 
<a name="397" /><span class="Maybe">     397:</span>     <span class="k">/* Iterators */</span>
<a name="398" /><span class="Maybe">     398:</span>     <span class="b">getiterfunc</span> <span class="b">tp_iter</span><span class="f">;</span>
<a name="399" /><span class="Maybe">     399:</span>     <span class="b">iternextfunc</span> <span class="b">tp_iternext</span><span class="f">;</span>
<a name="400" /><span class="Maybe">     400:</span> 
<a name="401" /><span class="Maybe">     401:</span>     <span class="k">/* Attribute descriptor and subclassing stuff */</span>
<a name="402" /><span class="Maybe">     402:</span>     <span class="m">struct</span> <span class="b">PyMethodDef</span> <span class="f">*</span><span class="b">tp_methods</span><span class="f">;</span>
<a name="403" /><span class="Maybe">     403:</span>     <span class="m">struct</span> <span class="b">PyMemberDef</span> <span class="f">*</span><span class="b">tp_members</span><span class="f">;</span>
<a name="404" /><span class="Maybe">     404:</span>     <span class="m">struct</span> <span class="b">PyGetSetDef</span> <span class="f">*</span><span class="b">tp_getset</span><span class="f">;</span>
<a name="405" /><span class="Maybe">     405:</span>     <span class="m">struct</span> <span class="b">_typeobject</span> <span class="f">*</span><span class="b">tp_base</span><span class="f">;</span>
<a name="406" /><span class="Maybe">     406:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">tp_dict</span><span class="f">;</span>
<a name="407" /><span class="Maybe">     407:</span>     <span class="b">descrgetfunc</span> <span class="b">tp_descr_get</span><span class="f">;</span>
<a name="408" /><span class="Maybe">     408:</span>     <span class="b">descrsetfunc</span> <span class="b">tp_descr_set</span><span class="f">;</span>
<a name="409" /><span class="Maybe">     409:</span>     <span class="b">Py_ssize_t</span> <span class="b">tp_dictoffset</span><span class="f">;</span>
<a name="410" /><span class="Maybe">     410:</span>     <span class="b">initproc</span> <span class="b">tp_init</span><span class="f">;</span>
<a name="411" /><span class="Maybe">     411:</span>     <span class="b">allocfunc</span> <span class="b">tp_alloc</span><span class="f">;</span>
<a name="412" /><span class="Maybe">     412:</span>     <span class="b">newfunc</span> <span class="b">tp_new</span><span class="f">;</span>
<a name="413" /><span class="Maybe">     413:</span>     <span class="b">freefunc</span> <span class="b">tp_free</span><span class="f">;</span> <span class="k">/* Low-level free-memory routine */</span>
<a name="414" /><span class="Maybe">     414:</span>     <span class="b">inquiry</span> <span class="b">tp_is_gc</span><span class="f">;</span> <span class="k">/* For PyObject_IS_GC */</span>
<a name="415" /><span class="Maybe">     415:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">tp_bases</span><span class="f">;</span>
<a name="416" /><span class="Maybe">     416:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">tp_mro</span><span class="f">;</span> <span class="k">/* method resolution order */</span>
<a name="417" /><span class="Maybe">     417:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">tp_cache</span><span class="f">;</span>
<a name="418" /><span class="Maybe">     418:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">tp_subclasses</span><span class="f">;</span>
<a name="419" /><span class="Maybe">     419:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">tp_weaklist</span><span class="f">;</span>
<a name="420" /><span class="Maybe">     420:</span>     <span class="b">destructor</span> <span class="b">tp_del</span><span class="f">;</span>
<a name="421" /><span class="Maybe">     421:</span> 
<a name="422" /><span class="Maybe">     422:</span>     <span class="k">/* Type attribute cache version tag. Added in version 2.6 */</span>
<a name="423" /><span class="Maybe">     423:</span>     <span class="m">unsigned</span> <span class="m">int</span> <span class="b">tp_version_tag</span><span class="f">;</span>
<a name="424" /><span class="Maybe">     424:</span> 
<a name="425" /><span class="Maybe">     425:</span>     <span class="b">destructor</span> <span class="b">tp_finalize</span><span class="f">;</span>
<a name="426" /><span class="Maybe">     426:</span> 
<a name="427" /><span class="False">     427:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">COUNT_ALLOCS</span>
<a name="428" /><span class="False">     428:</span>     <span class="k">/* these must be last and never explicitly initialized */</span>
<a name="429" /><span class="False">     429:</span>     <span class="b">Py_ssize_t</span> <span class="b">tp_allocs</span><span class="f">;</span>
<a name="430" /><span class="False">     430:</span>     <span class="b">Py_ssize_t</span> <span class="b">tp_frees</span><span class="f">;</span>
<a name="431" /><span class="False">     431:</span>     <span class="b">Py_ssize_t</span> <span class="b">tp_maxalloc</span><span class="f">;</span>
<a name="432" /><span class="False">     432:</span>     <span class="m">struct</span> <span class="b">_typeobject</span> <span class="f">*</span><span class="b">tp_prev</span><span class="f">;</span>
<a name="433" /><span class="False">     433:</span>     <span class="m">struct</span> <span class="b">_typeobject</span> <span class="f">*</span><span class="b">tp_next</span><span class="f">;</span>
<a name="434" /><span class="Maybe">     434:</span> <span class="f">#</span><span class="n">endif</span>
<a name="435" /><span class="Maybe">     435:</span> <span class="f">}</span> <span class="b">PyTypeObject</span><span class="f">;</span>
<a name="436" /><span class="Maybe">     436:</span> <span class="f">#</span><span class="n">endif</span>
<a name="437" /><span class="Maybe">     437:</span> 
<a name="438" /><span class="Maybe">     438:</span> <span class="m">typedef</span> <span class="m">struct</span><span class="f">{</span>
<a name="439" /><span class="Maybe">     439:</span>     <span class="m">int</span> <span class="b">slot</span><span class="f">;</span>    <span class="k">/* slot id, see below */</span>
<a name="440" /><span class="Maybe">     440:</span>     <span class="m">void</span> <span class="f">*</span><span class="b">pfunc</span><span class="f">;</span> <span class="k">/* function pointer */</span>
<a name="441" /><span class="Maybe">     441:</span> <span class="f">}</span> <span class="b">PyType_Slot</span><span class="f">;</span>
<a name="442" /><span class="Maybe">     442:</span> 
<a name="443" /><span class="Maybe">     443:</span> <span class="m">typedef</span> <span class="m">struct</span><span class="f">{</span>
<a name="444" /><span class="Maybe">     444:</span>     <span class="m">const</span> <span class="m">char</span><span class="f">*</span> <span class="b">name</span><span class="f">;</span>
<a name="445" /><span class="Maybe">     445:</span>     <span class="m">int</span> <span class="b">basicsize</span><span class="f">;</span>
<a name="446" /><span class="Maybe">     446:</span>     <span class="m">int</span> <span class="b">itemsize</span><span class="f">;</span>
<a name="447" /><span class="Maybe">     447:</span>     <span class="m">unsigned</span> <span class="m">int</span> <span class="b">flags</span><span class="f">;</span>
<a name="448" /><span class="Maybe">     448:</span>     <span class="b">PyType_Slot</span> <span class="f">*</span><span class="b">slots</span><span class="f">;</span> <span class="k">/* terminated by slot==0. */</span>
<a name="449" /><span class="Maybe">     449:</span> <span class="f">}</span> <span class="b">PyType_Spec</span><span class="f">;</span>
<a name="450" /><span class="Maybe">     450:</span> 
<a name="451" /><span class="Maybe">     451:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span><span class="f">*</span><span class="f">)</span> <span class="b">PyType_FromSpec</span><span class="f">(</span><span class="b">PyType_Spec</span><span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="452" /><span class="Maybe">     452:</span> <span class="f">#</span><span class="n">if</span> <span class="f">!</span><span class="b">defined</span><span class="f">(</span><span class="b">Py_LIMITED_API</span><span class="f">)</span> <span class="f">||</span> <span class="b">Py_LIMITED_API</span><span class="f">+</span><span class="c">0</span> <span class="f">&gt;=</span> <span class="c">0x03030000</span>
<a name="453" /><span class="Maybe">     453:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span><span class="f">*</span><span class="f">)</span> <span class="b">PyType_FromSpecWithBases</span><span class="f">(</span><span class="b">PyType_Spec</span><span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span><span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="454" /><span class="Maybe">     454:</span> <span class="f">#</span><span class="n">endif</span>
<a name="455" /><span class="Maybe">     455:</span> <span class="f">#</span><span class="n">if</span> <span class="f">!</span><span class="b">defined</span><span class="f">(</span><span class="b">Py_LIMITED_API</span><span class="f">)</span> <span class="f">||</span> <span class="b">Py_LIMITED_API</span><span class="f">+</span><span class="c">0</span> <span class="f">&gt;=</span> <span class="c">0x03040000</span>
<a name="456" /><span class="Maybe">     456:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">*</span><span class="f">)</span> <span class="b">PyType_GetSlot</span><span class="f">(</span><span class="b">PyTypeObject</span><span class="f">*</span><span class="f">,</span> <span class="m">int</span><span class="f">)</span><span class="f">;</span>
<a name="457" /><span class="Maybe">     457:</span> <span class="f">#</span><span class="n">endif</span>
<a name="458" /><span class="Maybe">     458:</span> 
<a name="459" /><span class="Maybe">     459:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="460" /><span class="Maybe">     460:</span> <span class="k">/* The *real* layout of a type object when allocated on the heap */</span>
<a name="461" /><span class="Maybe">     461:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="b">_heaptypeobject</span> <span class="f">{</span>
<a name="462" /><span class="Maybe">     462:</span>     <span class="k">/* Note: there&apos;s a dependency on the order of these members</span>
<a name="463" /><span class="Maybe">     463:</span> <span class="k">       in slotptr() in typeobject.c . */</span>
<a name="464" /><span class="Maybe">     464:</span>     <span class="b">PyTypeObject</span> <span class="b">ht_type</span><span class="f">;</span>
<a name="465" /><span class="Maybe">     465:</span>     <span class="b">PyAsyncMethods</span> <span class="b">as_async</span><span class="f">;</span>
<a name="466" /><span class="Maybe">     466:</span>     <span class="b">PyNumberMethods</span> <span class="b">as_number</span><span class="f">;</span>
<a name="467" /><span class="Maybe">     467:</span>     <span class="b">PyMappingMethods</span> <span class="b">as_mapping</span><span class="f">;</span>
<a name="468" /><span class="Maybe">     468:</span>     <span class="b">PySequenceMethods</span> <span class="b">as_sequence</span><span class="f">;</span> <span class="k">/* as_sequence comes after as_mapping,</span>
<a name="469" /><span class="Maybe">     469:</span> <span class="k">                                      so that the mapping wins when both</span>
<a name="470" /><span class="Maybe">     470:</span> <span class="k">                                      the mapping and the sequence define</span>
<a name="471" /><span class="Maybe">     471:</span> <span class="k">                                      a given operator (e.g. __getitem__).</span>
<a name="472" /><span class="Maybe">     472:</span> <span class="k">                                      see add_operators() in typeobject.c . */</span>
<a name="473" /><span class="Maybe">     473:</span>     <span class="b">PyBufferProcs</span> <span class="b">as_buffer</span><span class="f">;</span>
<a name="474" /><span class="Maybe">     474:</span>     <span class="b">PyObject</span> <span class="f">*</span><span class="b">ht_name</span><span class="f">,</span> <span class="f">*</span><span class="b">ht_slots</span><span class="f">,</span> <span class="f">*</span><span class="b">ht_qualname</span><span class="f">;</span>
<a name="475" /><span class="Maybe">     475:</span>     <span class="m">struct</span> <span class="b">_dictkeysobject</span> <span class="f">*</span><span class="b">ht_cached_keys</span><span class="f">;</span>
<a name="476" /><span class="Maybe">     476:</span>     <span class="k">/* here are optional user slots, followed by the members. */</span>
<a name="477" /><span class="Maybe">     477:</span> <span class="f">}</span> <span class="b">PyHeapTypeObject</span><span class="f">;</span>
<a name="478" /><span class="Maybe">     478:</span> 
<a name="479" /><span class="Maybe">     479:</span> <span class="k">/* access macro to the members which are floating &quot;behind&quot; the object */</span>
<a name="480" /><span class="Maybe">     480:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlIZWFwVHlwZV9HRVRfTUVNQkVSU18w"><span class="b">PyHeapType_GET_MEMBERS</span></a><span class="f">(</span><span class="b">etype</span><span class="f">)</span> \
<a name="481" /><span class="Maybe">     481:</span>     <span class="f">(</span><span class="f">(</span><span class="b">PyMemberDef</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="f">(</span><span class="f">(</span><span class="m">char</span> <span class="f">*</span><span class="f">)</span><span class="b">etype</span><span class="f">)</span> <span class="f">+</span> <a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">etype</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">tp_basicsize</span><span class="f">)</span><span class="f">)</span>
<a name="482" /><span class="Maybe">     482:</span> <span class="f">#</span><span class="n">endif</span>
<a name="483" /><span class="Maybe">     483:</span> 
<a name="484" /><span class="Maybe">     484:</span> <span class="k">/* Generic type check */</span>
<a name="485" /><span class="Maybe">     485:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyType_IsSubtype</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="486" /><span class="Maybe">     486:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlPYmplY3RfVHlwZUNoZWNrXzA_"><span class="b">PyObject_TypeCheck</span></a><span class="f">(</span><span class="b">ob</span><span class="f">,</span> <span class="b">tp</span><span class="f">)</span> \
<a name="487" /><span class="Maybe">     487:</span>     <span class="f">(</span><a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">ob</span><span class="f">)</span> <span class="f">==</span> <span class="f">(</span><span class="b">tp</span><span class="f">)</span> <span class="f">||</span> <span class="b">PyType_IsSubtype</span><span class="f">(</span><a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">ob</span><span class="f">)</span><span class="f">,</span> <span class="f">(</span><span class="b">tp</span><span class="f">)</span><span class="f">)</span><span class="f">)</span>
<a name="488" /><span class="Maybe">     488:</span> 
<a name="489" /><span class="Maybe">     489:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">PyTypeObject</span><span class="f">)</span> <span class="b">PyType_Type</span><span class="f">;</span> <span class="k">/* built-in &apos;type&apos; */</span>
<a name="490" /><span class="Maybe">     490:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">PyTypeObject</span><span class="f">)</span> <span class="b">PyBaseObject_Type</span><span class="f">;</span> <span class="k">/* built-in &apos;object&apos; */</span>
<a name="491" /><span class="Maybe">     491:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">PyTypeObject</span><span class="f">)</span> <span class="b">PySuper_Type</span><span class="f">;</span> <span class="k">/* built-in &apos;super&apos; */</span>
<a name="492" /><span class="Maybe">     492:</span> 
<a name="493" /><span class="Maybe">     493:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">unsigned</span> <span class="m">long</span><span class="f">)</span> <span class="b">PyType_GetFlags</span><span class="f">(</span><span class="b">PyTypeObject</span><span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="494" /><span class="Maybe">     494:</span> 
<a name="495" /><span class="Maybe">     495:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlUeXBlX0NoZWNrXzA_"><span class="b">PyType_Check</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> \
<a name="496" /><span class="Maybe">     496:</span>     <a href="macros_ref.html#_UHlUeXBlX0Zhc3RTdWJjbGFzc18w"><span class="b">PyType_FastSubclass</span></a><span class="f">(</span><a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">,</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19UWVBFX1NVQkNMQVNTXzA_"><span class="b">Py_TPFLAGS_TYPE_SUBCLASS</span></a><span class="f">)</span>
<a name="497" /><span class="Maybe">     497:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlUeXBlX0NoZWNrRXhhY3RfMA__"><span class="b">PyType_CheckExact</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">(</span><a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">==</span> <span class="f">&amp;</span><span class="b">PyType_Type</span><span class="f">)</span>
<a name="498" /><span class="Maybe">     498:</span> 
<a name="499" /><span class="Maybe">     499:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyType_Ready</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="500" /><span class="Maybe">     500:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyType_GenericAlloc</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">Py_ssize_t</span><span class="f">)</span><span class="f">;</span>
<a name="501" /><span class="Maybe">     501:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyType_GenericNew</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">,</span>
<a name="502" /><span class="Maybe">     502:</span>                                                <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="503" /><span class="Maybe">     503:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="504" /><span class="Maybe">     504:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyType_Lookup</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="505" /><span class="Maybe">     505:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyType_LookupId</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">_Py_Identifier</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="506" /><span class="Maybe">     506:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyObject_LookupSpecial</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">_Py_Identifier</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="507" /><span class="Maybe">     507:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyType_CalculateMetaclass</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="508" /><span class="Maybe">     508:</span> <span class="f">#</span><span class="n">endif</span>
<a name="509" /><span class="Maybe">     509:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">unsigned</span> <span class="m">int</span><span class="f">)</span> <span class="b">PyType_ClearCache</span><span class="f">(</span><span class="m">void</span><span class="f">)</span><span class="f">;</span>
<a name="510" /><span class="Maybe">     510:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">PyType_Modified</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="511" /><span class="Maybe">     511:</span> 
<a name="512" /><span class="Maybe">     512:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="513" /><span class="Maybe">     513:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyType_GetDocFromInternalDoc</span><span class="f">(</span><span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="f">,</span> <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="514" /><span class="Maybe">     514:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyType_GetTextSignatureFromInternalDoc</span><span class="f">(</span><span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="f">,</span> <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="515" /><span class="Maybe">     515:</span> <span class="f">#</span><span class="n">endif</span>
<a name="516" /><span class="Maybe">     516:</span> 
<a name="517" /><span class="Maybe">     517:</span> <span class="k">/* Generic operations on objects */</span>
<a name="518" /><span class="Maybe">     518:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="519" /><span class="Maybe">     519:</span> <span class="m">struct</span> <span class="b">_Py_Identifier</span><span class="f">;</span>
<a name="520" /><span class="Maybe">     520:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_Print</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">FILE</span> <span class="f">*</span><span class="f">,</span> <span class="m">int</span><span class="f">)</span><span class="f">;</span>
<a name="521" /><span class="Maybe">     521:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_BreakPoint</span><span class="f">(</span><span class="m">void</span><span class="f">)</span><span class="f">;</span>
<a name="522" /><span class="Maybe">     522:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_PyObject_Dump</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="523" /><span class="Maybe">     523:</span> <span class="f">#</span><span class="n">endif</span>
<a name="524" /><span class="Maybe">     524:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_Repr</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="525" /><span class="Maybe">     525:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_Str</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="526" /><span class="Maybe">     526:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_ASCII</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="527" /><span class="Maybe">     527:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_Bytes</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="528" /><span class="Maybe">     528:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_RichCompare</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">int</span><span class="f">)</span><span class="f">;</span>
<a name="529" /><span class="Maybe">     529:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_RichCompareBool</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">int</span><span class="f">)</span><span class="f">;</span>
<a name="530" /><span class="Maybe">     530:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_GetAttrString</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="531" /><span class="Maybe">     531:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_SetAttrString</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="532" /><span class="Maybe">     532:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_HasAttrString</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="533" /><span class="Maybe">     533:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_GetAttr</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="534" /><span class="Maybe">     534:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_SetAttr</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="535" /><span class="Maybe">     535:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_HasAttr</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="536" /><span class="Maybe">     536:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="537" /><span class="Maybe">     537:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">_PyObject_IsAbstract</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="538" /><span class="Maybe">     538:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyObject_GetAttrId</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">struct</span> <span class="b">_Py_Identifier</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="539" /><span class="Maybe">     539:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">_PyObject_SetAttrId</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">struct</span> <span class="b">_Py_Identifier</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="540" /><span class="Maybe">     540:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">_PyObject_HasAttrId</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">struct</span> <span class="b">_Py_Identifier</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="541" /><span class="Maybe">     541:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">*</span><span class="f">)</span> <span class="b">_PyObject_GetDictPtr</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="542" /><span class="Maybe">     542:</span> <span class="f">#</span><span class="n">endif</span>
<a name="543" /><span class="Maybe">     543:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_SelfIter</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="544" /><span class="Maybe">     544:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="545" /><span class="Maybe">     545:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyObject_NextNotImplemented</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="546" /><span class="Maybe">     546:</span> <span class="f">#</span><span class="n">endif</span>
<a name="547" /><span class="Maybe">     547:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_GenericGetAttr</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="548" /><span class="Maybe">     548:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_GenericSetAttr</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span>
<a name="549" /><span class="Maybe">     549:</span>                                               <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="550" /><span class="Maybe">     550:</span> <span class="f">#</span><span class="n">if</span> <span class="f">!</span><span class="b">defined</span><span class="f">(</span><span class="b">Py_LIMITED_API</span><span class="f">)</span> <span class="f">||</span> <span class="b">Py_LIMITED_API</span><span class="f">+</span><span class="c">0</span> <span class="f">&gt;=</span> <span class="c">0x03030000</span>
<a name="551" /><span class="Maybe">     551:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_GenericSetDict</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="552" /><span class="Maybe">     552:</span> <span class="f">#</span><span class="n">endif</span>
<a name="553" /><span class="Maybe">     553:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">Py_hash_t</span><span class="f">)</span> <span class="b">PyObject_Hash</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="554" /><span class="Maybe">     554:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">Py_hash_t</span><span class="f">)</span> <span class="b">PyObject_HashNotImplemented</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="555" /><span class="Maybe">     555:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_IsTrue</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="556" /><span class="Maybe">     556:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_Not</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="557" /><span class="Maybe">     557:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyCallable_Check</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="558" /><span class="Maybe">     558:</span> 
<a name="559" /><span class="Maybe">     559:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">PyObject_ClearWeakRefs</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="560" /><span class="Maybe">     560:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="561" /><span class="Maybe">     561:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">PyObject_CallFinalizer</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="562" /><span class="Maybe">     562:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">PyObject_CallFinalizerFromDealloc</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="563" /><span class="Maybe">     563:</span> <span class="f">#</span><span class="n">endif</span>
<a name="564" /><span class="Maybe">     564:</span> 
<a name="565" /><span class="Maybe">     565:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="566" /><span class="Maybe">     566:</span> <span class="k">/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes</span>
<a name="567" /><span class="Maybe">     567:</span> <span class="k">   dict as the last parameter. */</span>
<a name="568" /><span class="Maybe">     568:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span>
<a name="569" /><span class="Maybe">     569:</span> <span class="b">_PyObject_GenericGetAttrWithDict</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="570" /><span class="Maybe">     570:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span>
<a name="571" /><span class="Maybe">     571:</span> <span class="b">_PyObject_GenericSetAttrWithDict</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span>
<a name="572" /><span class="Maybe">     572:</span>                                  <span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="573" /><span class="Maybe">     573:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* !Py_LIMITED_API */</span>
<a name="574" /><span class="Maybe">     574:</span> 
<a name="575" /><span class="Maybe">     575:</span> <span class="k">/* Helper to look up a builtin object */</span>
<a name="576" /><span class="Maybe">     576:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="577" /><span class="Maybe">     577:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span>
<a name="578" /><span class="Maybe">     578:</span> <span class="b">_PyObject_GetBuiltin</span><span class="f">(</span><span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="b">name</span><span class="f">)</span><span class="f">;</span>
<a name="579" /><span class="Maybe">     579:</span> <span class="f">#</span><span class="n">endif</span>
<a name="580" /><span class="Maybe">     580:</span> 
<a name="581" /><span class="Maybe">     581:</span> <span class="k">/* PyObject_Dir(obj) acts like Python builtins.dir(obj), returning a</span>
<a name="582" /><span class="Maybe">     582:</span> <span class="k">   list of strings.  PyObject_Dir(NULL) is like builtins.dir(),</span>
<a name="583" /><span class="Maybe">     583:</span> <span class="k">   returning the names of the current locals.  In this case, if there are</span>
<a name="584" /><span class="Maybe">     584:</span> <span class="k">   no current locals, NULL is returned, and PyErr_Occurred() is false.</span>
<a name="585" /><span class="Maybe">     585:</span> <span class="k">*/</span>
<a name="586" /><span class="Maybe">     586:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">PyObject_Dir</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="587" /><span class="Maybe">     587:</span> 
<a name="588" /><span class="Maybe">     588:</span> 
<a name="589" /><span class="Maybe">     589:</span> <span class="k">/* Helpers for printing recursive container types */</span>
<a name="590" /><span class="Maybe">     590:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">Py_ReprEnter</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="591" /><span class="Maybe">     591:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">Py_ReprLeave</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="592" /><span class="Maybe">     592:</span> 
<a name="593" /><span class="Maybe">     593:</span> <span class="k">/* Flag bits for printing: */</span>
<a name="594" /><span class="Maybe">     594:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfUFJJTlRfUkFXXzA_"><span class="b">Py_PRINT_RAW</span></a>    <span class="c">1</span>       <span class="k">/* No string quotes etc. */</span>
<a name="595" /><span class="Maybe">     595:</span> 
<a name="596" /><span class="Maybe">     596:</span> <span class="k">/*</span>
<a name="597" /><span class="Maybe">     597:</span> <span class="k">`Type flags (tp_flags)</span>
<a name="598" /><span class="Maybe">     598:</span> <span class="k"></span>
<a name="599" /><span class="Maybe">     599:</span> <span class="k">These flags are used to extend the type structure in a backwards-compatible</span>
<a name="600" /><span class="Maybe">     600:</span> <span class="k">fashion. Extensions can use the flags to indicate (and test) when a given</span>
<a name="601" /><span class="Maybe">     601:</span> <span class="k">type structure contains a new feature. The Python core will use these when</span>
<a name="602" /><span class="Maybe">     602:</span> <span class="k">introducing new functionality between major revisions (to avoid mid-version</span>
<a name="603" /><span class="Maybe">     603:</span> <span class="k">changes in the PYTHON_API_VERSION).</span>
<a name="604" /><span class="Maybe">     604:</span> <span class="k"></span>
<a name="605" /><span class="Maybe">     605:</span> <span class="k">Arbitration of the flag bit positions will need to be coordinated among</span>
<a name="606" /><span class="Maybe">     606:</span> <span class="k">all extension writers who publically release their extensions (this will</span>
<a name="607" /><span class="Maybe">     607:</span> <span class="k">be fewer than you might expect!)..</span>
<a name="608" /><span class="Maybe">     608:</span> <span class="k"></span>
<a name="609" /><span class="Maybe">     609:</span> <span class="k">Most flags were removed as of Python 3.0 to make room for new flags.  (Some</span>
<a name="610" /><span class="Maybe">     610:</span> <span class="k">flags are not for backwards compatibility but to indicate the presence of an</span>
<a name="611" /><span class="Maybe">     611:</span> <span class="k">optional feature; these flags remain of course.)</span>
<a name="612" /><span class="Maybe">     612:</span> <span class="k"></span>
<a name="613" /><span class="Maybe">     613:</span> <span class="k">Type definitions should use Py_TPFLAGS_DEFAULT for their tp_flags value.</span>
<a name="614" /><span class="Maybe">     614:</span> <span class="k"></span>
<a name="615" /><span class="Maybe">     615:</span> <span class="k">Code can use PyType_HasFeature(type_ob, flag_value) to test whether the</span>
<a name="616" /><span class="Maybe">     616:</span> <span class="k">given type object has a specified feature.</span>
<a name="617" /><span class="Maybe">     617:</span> <span class="k">*/</span>
<a name="618" /><span class="Maybe">     618:</span> 
<a name="619" /><span class="Maybe">     619:</span> <span class="k">/* Set if the type object is dynamically allocated */</span>
<a name="620" /><span class="Maybe">     620:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19IRUFQVFlQRV8w"><span class="b">Py_TPFLAGS_HEAPTYPE</span></a> <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">9</span><span class="f">)</span>
<a name="621" /><span class="Maybe">     621:</span> 
<a name="622" /><span class="Maybe">     622:</span> <span class="k">/* Set if the type allows subclassing */</span>
<a name="623" /><span class="Maybe">     623:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19CQVNFVFlQRV8w"><span class="b">Py_TPFLAGS_BASETYPE</span></a> <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">10</span><span class="f">)</span>
<a name="624" /><span class="Maybe">     624:</span> 
<a name="625" /><span class="Maybe">     625:</span> <span class="k">/* Set if the type is &apos;ready&apos; -- fully initialized */</span>
<a name="626" /><span class="Maybe">     626:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19SRUFEWV8w"><span class="b">Py_TPFLAGS_READY</span></a> <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">12</span><span class="f">)</span>
<a name="627" /><span class="Maybe">     627:</span> 
<a name="628" /><span class="Maybe">     628:</span> <span class="k">/* Set while the type is being &apos;readied&apos;, to prevent recursive ready calls */</span>
<a name="629" /><span class="Maybe">     629:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19SRUFEWUlOR18w"><span class="b">Py_TPFLAGS_READYING</span></a> <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">13</span><span class="f">)</span>
<a name="630" /><span class="Maybe">     630:</span> 
<a name="631" /><span class="Maybe">     631:</span> <span class="k">/* Objects support garbage collection (see objimp.h) */</span>
<a name="632" /><span class="Maybe">     632:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19IQVZFX0dDXzA_"><span class="b">Py_TPFLAGS_HAVE_GC</span></a> <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">14</span><span class="f">)</span>
<a name="633" /><span class="Maybe">     633:</span> 
<a name="634" /><span class="Maybe">     634:</span> <span class="k">/* These two bits are preserved for Stackless Python, next after this is 17 */</span>
<a name="635" /><span class="False">     635:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">STACKLESS</span>
<a name="636" /><span class="False">     636:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19IQVZFX1NUQUNLTEVTU19FWFRFTlNJT05fMA__"><span class="b">Py_TPFLAGS_HAVE_STACKLESS_EXTENSION</span></a> <span class="f">(</span><span class="c">3UL</span> <span class="f">&lt;&lt;</span> <span class="c">15</span><span class="f">)</span>
<a name="637" /><span class="Maybe">     637:</span> <span class="f">#</span><span class="n">else</span>
<a name="638" /><span class="Maybe">     638:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19IQVZFX1NUQUNLTEVTU19FWFRFTlNJT05fMA__"><span class="b">Py_TPFLAGS_HAVE_STACKLESS_EXTENSION</span></a> <span class="c">0</span>
<a name="639" /><span class="Maybe">     639:</span> <span class="f">#</span><span class="n">endif</span>
<a name="640" /><span class="Maybe">     640:</span> 
<a name="641" /><span class="Maybe">     641:</span> <span class="k">/* Objects support type attribute cache */</span>
<a name="642" /><span class="Maybe">     642:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19IQVZFX1ZFUlNJT05fVEFHXzA_"><span class="b">Py_TPFLAGS_HAVE_VERSION_TAG</span></a>   <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">18</span><span class="f">)</span>
<a name="643" /><span class="Maybe">     643:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19WQUxJRF9WRVJTSU9OX1RBR18w"><span class="b">Py_TPFLAGS_VALID_VERSION_TAG</span></a>  <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">19</span><span class="f">)</span>
<a name="644" /><span class="Maybe">     644:</span> 
<a name="645" /><span class="Maybe">     645:</span> <span class="k">/* Type is abstract and cannot be instantiated */</span>
<a name="646" /><span class="Maybe">     646:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19JU19BQlNUUkFDVF8w"><span class="b">Py_TPFLAGS_IS_ABSTRACT</span></a> <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">20</span><span class="f">)</span>
<a name="647" /><span class="Maybe">     647:</span> 
<a name="648" /><span class="Maybe">     648:</span> <span class="k">/* These flags are used to determine if a type is a subclass. */</span>
<a name="649" /><span class="Maybe">     649:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19MT05HX1NVQkNMQVNTXzA_"><span class="b">Py_TPFLAGS_LONG_SUBCLASS</span></a>        <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">24</span><span class="f">)</span>
<a name="650" /><span class="Maybe">     650:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19MSVNUX1NVQkNMQVNTXzA_"><span class="b">Py_TPFLAGS_LIST_SUBCLASS</span></a>        <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">25</span><span class="f">)</span>
<a name="651" /><span class="Maybe">     651:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19UVVBMRV9TVUJDTEFTU18w"><span class="b">Py_TPFLAGS_TUPLE_SUBCLASS</span></a>       <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">26</span><span class="f">)</span>
<a name="652" /><span class="Maybe">     652:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19CWVRFU19TVUJDTEFTU18w"><span class="b">Py_TPFLAGS_BYTES_SUBCLASS</span></a>       <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">27</span><span class="f">)</span>
<a name="653" /><span class="Maybe">     653:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19VTklDT0RFX1NVQkNMQVNTXzA_"><span class="b">Py_TPFLAGS_UNICODE_SUBCLASS</span></a>     <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">28</span><span class="f">)</span>
<a name="654" /><span class="Maybe">     654:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19ESUNUX1NVQkNMQVNTXzA_"><span class="b">Py_TPFLAGS_DICT_SUBCLASS</span></a>        <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">29</span><span class="f">)</span>
<a name="655" /><span class="Maybe">     655:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19CQVNFX0VYQ19TVUJDTEFTU18w"><span class="b">Py_TPFLAGS_BASE_EXC_SUBCLASS</span></a>    <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">30</span><span class="f">)</span>
<a name="656" /><span class="Maybe">     656:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19UWVBFX1NVQkNMQVNTXzA_"><span class="b">Py_TPFLAGS_TYPE_SUBCLASS</span></a>        <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">31</span><span class="f">)</span>
<a name="657" /><span class="Maybe">     657:</span> 
<a name="658" /><span class="Maybe">     658:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFBGTEFHU19ERUZBVUxUXzA_"><span class="b">Py_TPFLAGS_DEFAULT</span></a>  <span class="f">(</span> \
<a name="659" /><span class="Maybe">     659:</span>                  <a href="macros_ref.html#_UHlfVFBGTEFHU19IQVZFX1NUQUNLTEVTU19FWFRFTlNJT05fMA__"><span class="b">Py_TPFLAGS_HAVE_STACKLESS_EXTENSION</span></a> <span class="f">|</span> \
<a name="660" /><span class="Maybe">     660:</span>                  <a href="macros_ref.html#_UHlfVFBGTEFHU19IQVZFX1ZFUlNJT05fVEFHXzA_"><span class="b">Py_TPFLAGS_HAVE_VERSION_TAG</span></a> <span class="f">|</span> \
<a name="661" /><span class="Maybe">     661:</span>                 <span class="c">0</span><span class="f">)</span>
<a name="662" /><span class="Maybe">     662:</span> 
<a name="663" /><span class="Maybe">     663:</span> <span class="k">/* NOTE: The following flags reuse lower bits (removed as part of the</span>
<a name="664" /><span class="Maybe">     664:</span> <span class="k"> * Python 3.0 transition). */</span>
<a name="665" /><span class="Maybe">     665:</span> 
<a name="666" /><span class="Maybe">     666:</span> <span class="k">/* Type structure has tp_finalize member (3.4) */</span>
<a name="667" /><span class="Maybe">     667:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfVFBGTEFHU19IQVZFX0ZJTkFMSVpFXzA_"><span class="b">Py_TPFLAGS_HAVE_FINALIZE</span></a> <span class="f">(</span><span class="c">1UL</span> <span class="f">&lt;&lt;</span> <span class="c">0</span><span class="f">)</span>
<a name="668" /><span class="Maybe">     668:</span> 
<a name="669" /><span class="False">     669:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">Py_LIMITED_API</span>
<a name="670" /><span class="False">     670:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlUeXBlX0hhc0ZlYXR1cmVfMA__"><span class="b">PyType_HasFeature</span></a><span class="f">(</span><span class="b">t</span><span class="f">,</span><span class="b">f</span><span class="f">)</span>  <span class="f">(</span><span class="f">(</span><span class="b">PyType_GetFlags</span><span class="f">(</span><span class="b">t</span><span class="f">)</span> <span class="f">&amp;</span> <span class="f">(</span><span class="b">f</span><span class="f">)</span><span class="f">)</span> <span class="f">!=</span> <span class="c">0</span><span class="f">)</span>
<a name="671" /><span class="Maybe">     671:</span> <span class="f">#</span><span class="n">else</span>
<a name="672" /><span class="Maybe">     672:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlUeXBlX0hhc0ZlYXR1cmVfMA__"><span class="b">PyType_HasFeature</span></a><span class="f">(</span><span class="b">t</span><span class="f">,</span><span class="b">f</span><span class="f">)</span>  <span class="f">(</span><span class="f">(</span><span class="f">(</span><span class="b">t</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">tp_flags</span> <span class="f">&amp;</span> <span class="f">(</span><span class="b">f</span><span class="f">)</span><span class="f">)</span> <span class="f">!=</span> <span class="c">0</span><span class="f">)</span>
<a name="673" /><span class="Maybe">     673:</span> <span class="f">#</span><span class="n">endif</span>
<a name="674" /><span class="Maybe">     674:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlUeXBlX0Zhc3RTdWJjbGFzc18w"><span class="b">PyType_FastSubclass</span></a><span class="f">(</span><span class="b">t</span><span class="f">,</span><span class="b">f</span><span class="f">)</span>  <a href="macros_ref.html#_UHlUeXBlX0hhc0ZlYXR1cmVfMA__"><span class="b">PyType_HasFeature</span></a><span class="f">(</span><span class="b">t</span><span class="f">,</span><span class="b">f</span><span class="f">)</span>
<a name="675" /><span class="Maybe">     675:</span> 
<a name="676" /><span class="Maybe">     676:</span> 
<a name="677" /><span class="Maybe">     677:</span> <span class="k">/*</span>
<a name="678" /><span class="Maybe">     678:</span> <span class="k">The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement</span>
<a name="679" /><span class="Maybe">     679:</span> <span class="k">reference counts.  Py_DECREF calls the object&apos;s deallocator function when</span>
<a name="680" /><span class="Maybe">     680:</span> <span class="k">the refcount falls to 0; for</span>
<a name="681" /><span class="Maybe">     681:</span> <span class="k">objects that don&apos;t contain references to other objects or heap memory</span>
<a name="682" /><span class="Maybe">     682:</span> <span class="k">this can be the standard function free().  Both macros can be used</span>
<a name="683" /><span class="Maybe">     683:</span> <span class="k">wherever a void expression is allowed.  The argument must not be a</span>
<a name="684" /><span class="Maybe">     684:</span> <span class="k">NULL pointer.  If it may be NULL, use Py_XINCREF/Py_XDECREF instead.</span>
<a name="685" /><span class="Maybe">     685:</span> <span class="k">The macro _Py_NewReference(op) initialize reference counts to 1, and</span>
<a name="686" /><span class="Maybe">     686:</span> <span class="k">in special builds (Py_REF_DEBUG, Py_TRACE_REFS) performs additional</span>
<a name="687" /><span class="Maybe">     687:</span> <span class="k">bookkeeping appropriate to the special build.</span>
<a name="688" /><span class="Maybe">     688:</span> <span class="k"></span>
<a name="689" /><span class="Maybe">     689:</span> <span class="k">We assume that the reference count field can never overflow; this can</span>
<a name="690" /><span class="Maybe">     690:</span> <span class="k">be proven when the size of the field is the same as the pointer size, so</span>
<a name="691" /><span class="Maybe">     691:</span> <span class="k">we ignore the possibility.  Provided a C int is at least 32 bits (which</span>
<a name="692" /><span class="Maybe">     692:</span> <span class="k">is implicitly assumed in many parts of this code), that&apos;s enough for</span>
<a name="693" /><span class="Maybe">     693:</span> <span class="k">about 2**31 references to an object.</span>
<a name="694" /><span class="Maybe">     694:</span> <span class="k"></span>
<a name="695" /><span class="Maybe">     695:</span> <span class="k">XXX The following became out of date in Python 2.2, but I&apos;m not sure</span>
<a name="696" /><span class="Maybe">     696:</span> <span class="k">XXX what the full truth is now.  Certainly, heap-allocated type objects</span>
<a name="697" /><span class="Maybe">     697:</span> <span class="k">XXX can and should be deallocated.</span>
<a name="698" /><span class="Maybe">     698:</span> <span class="k">Type objects should never be deallocated; the type pointer in an object</span>
<a name="699" /><span class="Maybe">     699:</span> <span class="k">is not considered to be a reference to the type object, to save</span>
<a name="700" /><span class="Maybe">     700:</span> <span class="k">complications in the deallocation function.  (This is actually a</span>
<a name="701" /><span class="Maybe">     701:</span> <span class="k">decision that&apos;s up to the implementer of each new type so if you want,</span>
<a name="702" /><span class="Maybe">     702:</span> <span class="k">you can count such references to the type object.)</span>
<a name="703" /><span class="Maybe">     703:</span> <span class="k">*/</span>
<a name="704" /><span class="Maybe">     704:</span> 
<a name="705" /><span class="Maybe">     705:</span> <span class="k">/* First define a pile of simple helper macros, one set per special</span>
<a name="706" /><span class="Maybe">     706:</span> <span class="k"> * build symbol.  These either expand to the obvious things, or to</span>
<a name="707" /><span class="Maybe">     707:</span> <span class="k"> * nothing at all when the special mode isn&apos;t in effect.  The main</span>
<a name="708" /><span class="Maybe">     708:</span> <span class="k"> * macros can later be defined just once then, yet expand to different</span>
<a name="709" /><span class="Maybe">     709:</span> <span class="k"> * things depending on which special build options are and aren&apos;t in effect.</span>
<a name="710" /><span class="Maybe">     710:</span> <span class="k"> * Trust me &lt;wink&gt;:  while painful, this is 20x easier to understand than,</span>
<a name="711" /><span class="Maybe">     711:</span> <span class="k"> * e.g, defining _Py_NewReference five different times in a maze of nested</span>
<a name="712" /><span class="Maybe">     712:</span> <span class="k"> * #ifdefs (we used to do that -- it was impenetrable).</span>
<a name="713" /><span class="Maybe">     713:</span> <span class="k"> */</span>
<a name="714" /><span class="Maybe">     714:</span> <span class="f">#</span><span class="n">ifdef</span> <a href="macros_ref.html#_UHlfUkVGX0RFQlVHXzA_"><span class="b">Py_REF_DEBUG</span></a>
<a name="715" /><span class="Maybe">     715:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">Py_ssize_t</span><span class="f">)</span> <span class="b">_Py_RefTotal</span><span class="f">;</span>
<a name="716" /><span class="Maybe">     716:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_NegativeRefcount</span><span class="f">(</span><span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="b">fname</span><span class="f">,</span>
<a name="717" /><span class="Maybe">     717:</span>                                             <span class="m">int</span> <span class="b">lineno</span><span class="f">,</span> <span class="b">PyObject</span> <span class="f">*</span><span class="b">op</span><span class="f">)</span><span class="f">;</span>
<a name="718" /><span class="Maybe">     718:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="b">Py_ssize_t</span><span class="f">)</span> <span class="b">_Py_GetRefTotal</span><span class="f">(</span><span class="m">void</span><span class="f">)</span><span class="f">;</span>
<a name="719" /><span class="Maybe">     719:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X0lOQ19SRUZUT1RBTF8w"><span class="b">_Py_INC_REFTOTAL</span></a>        <span class="b">_Py_RefTotal</span><span class="f">++</span>
<a name="720" /><span class="Maybe">     720:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X0RFQ19SRUZUT1RBTF8w"><span class="b">_Py_DEC_REFTOTAL</span></a>        <span class="b">_Py_RefTotal</span><span class="f">--</span>
<a name="721" /><span class="Maybe">     721:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X1JFRl9ERUJVR19DT01NQV8w"><span class="b">_Py_REF_DEBUG_COMMA</span></a>     <span class="f">,</span>
<a name="722" /><span class="Maybe">     722:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X0NIRUNLX1JFRkNOVF8w"><span class="b">_Py_CHECK_REFCNT</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span>                                    \
<a name="723" /><span class="Maybe">     723:</span> <span class="f">{</span>       <span class="m">if</span> <span class="f">(</span><span class="f">(</span><span class="f">(</span><span class="b">PyObject</span><span class="f">*</span><span class="f">)</span><span class="b">OP</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">ob_refcnt</span> <span class="f">&lt;</span> <span class="c">0</span><span class="f">)</span>                             \
<a name="724" /><span class="Maybe">     724:</span>                 <span class="b">_Py_NegativeRefcount</span><span class="f">(</span><span class="b">__FILE__</span><span class="f">,</span> <span class="b">__LINE__</span><span class="f">,</span>        \
<a name="725" /><span class="Maybe">     725:</span>                                      <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">OP</span><span class="f">)</span><span class="f">)</span><span class="f">;</span>         \
<a name="726" /><span class="Maybe">     726:</span> <span class="f">}</span>
<a name="727" /><span class="Maybe">     727:</span> <span class="k">/* Py_REF_DEBUG also controls the display of refcounts and memory block</span>
<a name="728" /><span class="Maybe">     728:</span> <span class="k"> * allocations at the interactive prompt and at interpreter shutdown</span>
<a name="729" /><span class="Maybe">     729:</span> <span class="k"> */</span>
<a name="730" /><span class="Maybe">     730:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_PyDebug_PrintTotalRefs</span><span class="f">(</span><span class="m">void</span><span class="f">)</span><span class="f">;</span>
<a name="731" /><span class="Maybe">     731:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1BZX0RFQlVHX1BSSU5UX1RPVEFMX1JFRlNfMA__"><span class="b">_PY_DEBUG_PRINT_TOTAL_REFS</span></a><span class="f">(</span><span class="f">)</span> <span class="b">_PyDebug_PrintTotalRefs</span><span class="f">(</span><span class="f">)</span>
<a name="732" /><span class="False">     732:</span> <span class="f">#</span><span class="n">else</span>
<a name="733" /><span class="False">     733:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X0lOQ19SRUZUT1RBTF8w"><span class="b">_Py_INC_REFTOTAL</span></a>
<a name="734" /><span class="False">     734:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X0RFQ19SRUZUT1RBTF8w"><span class="b">_Py_DEC_REFTOTAL</span></a>
<a name="735" /><span class="False">     735:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X1JFRl9ERUJVR19DT01NQV8w"><span class="b">_Py_REF_DEBUG_COMMA</span></a>
<a name="736" /><span class="False">     736:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_X1B5X0NIRUNLX1JFRkNOVF8w"><span class="b">_Py_CHECK_REFCNT</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span>    <span class="k">/* a semicolon */</span><span class="f">;</span>
<a name="737" /><span class="False">     737:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1BZX0RFQlVHX1BSSU5UX1RPVEFMX1JFRlNfMA__"><span class="b">_PY_DEBUG_PRINT_TOTAL_REFS</span></a><span class="f">(</span><span class="f">)</span>
<a name="738" /><span class="Maybe">     738:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* Py_REF_DEBUG */</span>
<a name="739" /><span class="Maybe">     739:</span> 
<a name="740" /><span class="False">     740:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">COUNT_ALLOCS</span>
<a name="741" /><span class="False">     741:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">inc_count</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="742" /><span class="False">     742:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">dec_count</span><span class="f">(</span><span class="b">PyTypeObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="743" /><span class="False">     743:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1B5X0lOQ19UUEFMTE9DU18w"><span class="b">_Py_INC_TPALLOCS</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span>    <span class="b">inc_count</span><span class="f">(</span><a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span><span class="f">)</span>
<a name="744" /><span class="False">     744:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1B5X0lOQ19UUEZSRUVTXzA_"><span class="b">_Py_INC_TPFREES</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span>     <span class="b">dec_count</span><span class="f">(</span><a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span><span class="f">)</span>
<a name="745" /><span class="False">     745:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1B5X0RFQ19UUEZSRUVTXzA_"><span class="b">_Py_DEC_TPFREES</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span>     <a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">tp_frees</span><span class="f">--</span>
<a name="746" /><span class="False">     746:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1B5X0NPVU5UX0FMTE9DU19DT01NQV8w"><span class="b">_Py_COUNT_ALLOCS_COMMA</span></a>  <span class="f">,</span>
<a name="747" /><span class="Maybe">     747:</span> <span class="f">#</span><span class="n">else</span>
<a name="748" /><span class="Maybe">     748:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1B5X0lOQ19UUEFMTE9DU18w"><span class="b">_Py_INC_TPALLOCS</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span>
<a name="749" /><span class="Maybe">     749:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1B5X0lOQ19UUEZSRUVTXzA_"><span class="b">_Py_INC_TPFREES</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span>
<a name="750" /><span class="Maybe">     750:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1B5X0RFQ19UUEZSRUVTXzA_"><span class="b">_Py_DEC_TPFREES</span></a><span class="f">(</span><span class="b">OP</span><span class="f">)</span>
<a name="751" /><span class="Maybe">     751:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_X1B5X0NPVU5UX0FMTE9DU19DT01NQV8w"><span class="b">_Py_COUNT_ALLOCS_COMMA</span></a>
<a name="752" /><span class="Maybe">     752:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* COUNT_ALLOCS */</span>
<a name="753" /><span class="Maybe">     753:</span> 
<a name="754" /><span class="Maybe">     754:</span> <span class="f">#</span><span class="n">ifdef</span> <a href="macros_ref.html#_UHlfVFJBQ0VfUkVGU18w"><span class="b">Py_TRACE_REFS</span></a>
<a name="755" /><span class="Maybe">     755:</span> <span class="k">/* Py_TRACE_REFS is such major surgery that we call external routines. */</span>
<a name="756" /><span class="Maybe">     756:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_NewReference</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="757" /><span class="Maybe">     757:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_ForgetReference</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="758" /><span class="Maybe">     758:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_Dealloc</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="759" /><span class="Maybe">     759:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_PrintReferences</span><span class="f">(</span><span class="b">FILE</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="760" /><span class="Maybe">     760:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_PrintReferenceAddresses</span><span class="f">(</span><span class="b">FILE</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="761" /><span class="Maybe">     761:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_AddToAllObjects</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">,</span> <span class="m">int</span> <span class="b">force</span><span class="f">)</span><span class="f">;</span>
<a name="762" /><span class="Maybe">     762:</span> 
<a name="763" /><span class="False">     763:</span> <span class="f">#</span><span class="n">else</span>
<a name="764" /><span class="False">     764:</span> <span class="k">/* Without Py_TRACE_REFS, there&apos;s little enough to do that we expand code</span>
<a name="765" /><span class="False">     765:</span> <span class="k"> * inline.</span>
<a name="766" /><span class="False">     766:</span> <span class="k"> */</span>
<a name="767" /><span class="False">     767:</span> <span class="f">#</span><span class="n">define</span> <span class="b">_Py_NewReference</span><span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">(</span>                          \
<a name="768" /><span class="False">     768:</span>     <a href="macros_noref.html#_X1B5X0lOQ19UUEFMTE9DU18w"><span class="b">_Py_INC_TPALLOCS</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> <a href="macros_noref.html#_X1B5X0NPVU5UX0FMTE9DU19DT01NQV8w"><span class="b">_Py_COUNT_ALLOCS_COMMA</span></a>         \
<a name="769" /><span class="False">     769:</span>     <a href="macros_ref.html#_X1B5X0lOQ19SRUZUT1RBTF8w"><span class="b">_Py_INC_REFTOTAL</span></a>  <a href="macros_ref.html#_X1B5X1JFRl9ERUJVR19DT01NQV8w"><span class="b">_Py_REF_DEBUG_COMMA</span></a>               \
<a name="770" /><span class="False">     770:</span>     <a href="macros_ref.html#_UHlfUkVGQ05UXzA_"><span class="b">Py_REFCNT</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">=</span> <span class="c">1</span><span class="f">)</span>
<a name="771" /><span class="False">     771:</span> 
<a name="772" /><span class="False">     772:</span> <span class="f">#</span><span class="n">define</span> <span class="b">_Py_ForgetReference</span><span class="f">(</span><span class="b">op</span><span class="f">)</span> <a href="macros_noref.html#_X1B5X0lOQ19UUEZSRUVTXzA_"><span class="b">_Py_INC_TPFREES</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span>
<a name="773" /><span class="False">     773:</span> 
<a name="774" /><span class="False">     774:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">Py_LIMITED_API</span>
<a name="775" /><span class="False">     775:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_Py_Dealloc</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="776" /><span class="False">     776:</span> <span class="f">#</span><span class="n">else</span>
<a name="777" /><span class="False">     777:</span> <span class="f">#</span><span class="n">define</span> <span class="b">_Py_Dealloc</span><span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">(</span>                               \
<a name="778" /><span class="False">     778:</span>     <a href="macros_noref.html#_X1B5X0lOQ19UUEZSRUVTXzA_"><span class="b">_Py_INC_TPFREES</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> <a href="macros_noref.html#_X1B5X0NPVU5UX0FMTE9DU19DT01NQV8w"><span class="b">_Py_COUNT_ALLOCS_COMMA</span></a>          \
<a name="779" /><span class="False">     779:</span>     <span class="f">(</span><span class="f">*</span><a href="macros_ref.html#_UHlfVFlQRV8w"><span class="b">Py_TYPE</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">tp_dealloc</span><span class="f">)</span><span class="f">(</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">)</span><span class="f">)</span>
<a name="780" /><span class="False">     780:</span> <span class="f">#</span><span class="n">endif</span>
<a name="781" /><span class="Maybe">     781:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* !Py_TRACE_REFS */</span>
<a name="782" /><span class="Maybe">     782:</span> 
<a name="783" /><span class="Maybe">     783:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfSU5DUkVGXzA_"><span class="b">Py_INCREF</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">(</span>                         \
<a name="784" /><span class="Maybe">     784:</span>     <a href="macros_ref.html#_X1B5X0lOQ19SRUZUT1RBTF8w"><span class="b">_Py_INC_REFTOTAL</span></a>  <a href="macros_ref.html#_X1B5X1JFRl9ERUJVR19DT01NQV8w"><span class="b">_Py_REF_DEBUG_COMMA</span></a>       \
<a name="785" /><span class="Maybe">     785:</span>     <span class="f">(</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">ob_refcnt</span><span class="f">++</span><span class="f">)</span>
<a name="786" /><span class="Maybe">     786:</span> 
<a name="787" /><span class="Maybe">     787:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfREVDUkVGXzA_"><span class="b">Py_DECREF</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span>                                   \
<a name="788" /><span class="Maybe">     788:</span>     <span class="m">do</span> <span class="f">{</span>                                                \
<a name="789" /><span class="Maybe">     789:</span>         <span class="b">PyObject</span> <span class="f">*</span><span class="b">_py_decref_tmp</span> <span class="f">=</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">;</span>    \
<a name="790" /><span class="Maybe">     790:</span>         <span class="m">if</span> <span class="f">(</span><a href="macros_ref.html#_X1B5X0RFQ19SRUZUT1RBTF8w"><span class="b">_Py_DEC_REFTOTAL</span></a>  <a href="macros_ref.html#_X1B5X1JFRl9ERUJVR19DT01NQV8w"><span class="b">_Py_REF_DEBUG_COMMA</span></a>       \
<a name="791" /><span class="Maybe">     791:</span>         <span class="f">--</span><span class="f">(</span><span class="b">_py_decref_tmp</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">ob_refcnt</span> <span class="f">!=</span> <span class="c">0</span><span class="f">)</span>             \
<a name="792" /><span class="Maybe">     792:</span>             <a href="macros_ref.html#_X1B5X0NIRUNLX1JFRkNOVF8w"><span class="b">_Py_CHECK_REFCNT</span></a><span class="f">(</span><span class="b">_py_decref_tmp</span><span class="f">)</span>            \
<a name="793" /><span class="Maybe">     793:</span>         <span class="m">else</span>                                            \
<a name="794" /><span class="Maybe">     794:</span>             <span class="b">_Py_Dealloc</span><span class="f">(</span><span class="b">_py_decref_tmp</span><span class="f">)</span><span class="f">;</span>                \
<a name="795" /><span class="Maybe">     795:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="796" /><span class="Maybe">     796:</span> 
<a name="797" /><span class="Maybe">     797:</span> <span class="k">/* Safely decref `op` and set `op` to NULL, especially useful in tp_clear</span>
<a name="798" /><span class="Maybe">     798:</span> <span class="k"> * and tp_dealloc implementations.</span>
<a name="799" /><span class="Maybe">     799:</span> <span class="k"> *</span>
<a name="800" /><span class="Maybe">     800:</span> <span class="k"> * Note that &quot;the obvious&quot; code can be deadly:</span>
<a name="801" /><span class="Maybe">     801:</span> <span class="k"> *</span>
<a name="802" /><span class="Maybe">     802:</span> <span class="k"> *     Py_XDECREF(op);</span>
<a name="803" /><span class="Maybe">     803:</span> <span class="k"> *     op = NULL;</span>
<a name="804" /><span class="Maybe">     804:</span> <span class="k"> *</span>
<a name="805" /><span class="Maybe">     805:</span> <span class="k"> * Typically, `op` is something like self-&gt;containee, and `self` is done</span>
<a name="806" /><span class="Maybe">     806:</span> <span class="k"> * using its `containee` member.  In the code sequence above, suppose</span>
<a name="807" /><span class="Maybe">     807:</span> <span class="k"> * `containee` is non-NULL with a refcount of 1.  Its refcount falls to</span>
<a name="808" /><span class="Maybe">     808:</span> <span class="k"> * 0 on the first line, which can trigger an arbitrary amount of code,</span>
<a name="809" /><span class="Maybe">     809:</span> <span class="k"> * possibly including finalizers (like __del__ methods or weakref callbacks)</span>
<a name="810" /><span class="Maybe">     810:</span> <span class="k"> * coded in Python, which in turn can release the GIL and allow other threads</span>
<a name="811" /><span class="Maybe">     811:</span> <span class="k"> * to run, etc.  Such code may even invoke methods of `self` again, or cause</span>
<a name="812" /><span class="Maybe">     812:</span> <span class="k"> * cyclic gc to trigger, but-- oops! --self-&gt;containee still points to the</span>
<a name="813" /><span class="Maybe">     813:</span> <span class="k"> * object being torn down, and it may be in an insane state while being torn</span>
<a name="814" /><span class="Maybe">     814:</span> <span class="k"> * down.  This has in fact been a rich historic source of miserable (rare &amp;</span>
<a name="815" /><span class="Maybe">     815:</span> <span class="k"> * hard-to-diagnose) segfaulting (and other) bugs.</span>
<a name="816" /><span class="Maybe">     816:</span> <span class="k"> *</span>
<a name="817" /><span class="Maybe">     817:</span> <span class="k"> * The safe way is:</span>
<a name="818" /><span class="Maybe">     818:</span> <span class="k"> *</span>
<a name="819" /><span class="Maybe">     819:</span> <span class="k"> *      Py_CLEAR(op);</span>
<a name="820" /><span class="Maybe">     820:</span> <span class="k"> *</span>
<a name="821" /><span class="Maybe">     821:</span> <span class="k"> * That arranges to set `op` to NULL _before_ decref&apos;ing, so that any code</span>
<a name="822" /><span class="Maybe">     822:</span> <span class="k"> * triggered as a side-effect of `op` getting torn down no longer believes</span>
<a name="823" /><span class="Maybe">     823:</span> <span class="k"> * `op` points to a valid object.</span>
<a name="824" /><span class="Maybe">     824:</span> <span class="k"> *</span>
<a name="825" /><span class="Maybe">     825:</span> <span class="k"> * There are cases where it&apos;s safe to use the naive code, but they&apos;re brittle.</span>
<a name="826" /><span class="Maybe">     826:</span> <span class="k"> * For example, if `op` points to a Python integer, you know that destroying</span>
<a name="827" /><span class="Maybe">     827:</span> <span class="k"> * one of those can&apos;t cause problems -- but in part that relies on that</span>
<a name="828" /><span class="Maybe">     828:</span> <span class="k"> * Python integers aren&apos;t currently weakly referencable.  Best practice is</span>
<a name="829" /><span class="Maybe">     829:</span> <span class="k"> * to use Py_CLEAR() even if you can&apos;t think of a reason for why you need to.</span>
<a name="830" /><span class="Maybe">     830:</span> <span class="k"> */</span>
<a name="831" /><span class="Maybe">     831:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfQ0xFQVJfMA__"><span class="b">Py_CLEAR</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span>                            \
<a name="832" /><span class="Maybe">     832:</span>     <span class="m">do</span> <span class="f">{</span>                                        \
<a name="833" /><span class="Maybe">     833:</span>         <span class="b">PyObject</span> <span class="f">*</span><span class="b">_py_tmp</span> <span class="f">=</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">;</span>   \
<a name="834" /><span class="Maybe">     834:</span>         <span class="m">if</span> <span class="f">(</span><span class="b">_py_tmp</span> <span class="f">!=</span> <a href="macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">)</span> <span class="f">{</span>                  \
<a name="835" /><span class="Maybe">     835:</span>             <span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">=</span> <a href="macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">;</span>                        \
<a name="836" /><span class="Maybe">     836:</span>             <a href="macros_ref.html#_UHlfREVDUkVGXzA_"><span class="b">Py_DECREF</span></a><span class="f">(</span><span class="b">_py_tmp</span><span class="f">)</span><span class="f">;</span>                 \
<a name="837" /><span class="Maybe">     837:</span>         <span class="f">}</span>                                       \
<a name="838" /><span class="Maybe">     838:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="839" /><span class="Maybe">     839:</span> 
<a name="840" /><span class="Maybe">     840:</span> <span class="k">/* Macros to use in case the object pointer may be NULL: */</span>
<a name="841" /><span class="Maybe">     841:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfWElOQ1JFRl8w"><span class="b">Py_XINCREF</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span>                                \
<a name="842" /><span class="Maybe">     842:</span>     <span class="m">do</span> <span class="f">{</span>                                              \
<a name="843" /><span class="Maybe">     843:</span>         <span class="b">PyObject</span> <span class="f">*</span><span class="b">_py_xincref_tmp</span> <span class="f">=</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">;</span> \
<a name="844" /><span class="Maybe">     844:</span>         <span class="m">if</span> <span class="f">(</span><span class="b">_py_xincref_tmp</span> <span class="f">!=</span> <a href="macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">)</span>                  \
<a name="845" /><span class="Maybe">     845:</span>             <a href="macros_ref.html#_UHlfSU5DUkVGXzA_"><span class="b">Py_INCREF</span></a><span class="f">(</span><span class="b">_py_xincref_tmp</span><span class="f">)</span><span class="f">;</span>               \
<a name="846" /><span class="Maybe">     846:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="847" /><span class="Maybe">     847:</span> 
<a name="848" /><span class="Maybe">     848:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfWERFQ1JFRl8w"><span class="b">Py_XDECREF</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span>                                \
<a name="849" /><span class="Maybe">     849:</span>     <span class="m">do</span> <span class="f">{</span>                                              \
<a name="850" /><span class="Maybe">     850:</span>         <span class="b">PyObject</span> <span class="f">*</span><span class="b">_py_xdecref_tmp</span> <span class="f">=</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">;</span> \
<a name="851" /><span class="Maybe">     851:</span>         <span class="m">if</span> <span class="f">(</span><span class="b">_py_xdecref_tmp</span> <span class="f">!=</span> <a href="macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">)</span>                  \
<a name="852" /><span class="Maybe">     852:</span>             <a href="macros_ref.html#_UHlfREVDUkVGXzA_"><span class="b">Py_DECREF</span></a><span class="f">(</span><span class="b">_py_xdecref_tmp</span><span class="f">)</span><span class="f">;</span>               \
<a name="853" /><span class="Maybe">     853:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="854" /><span class="Maybe">     854:</span> 
<a name="855" /><span class="Maybe">     855:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="856" /><span class="Maybe">     856:</span> <span class="k">/* Safely decref `op` and set `op` to `op2`.</span>
<a name="857" /><span class="Maybe">     857:</span> <span class="k"> *</span>
<a name="858" /><span class="Maybe">     858:</span> <span class="k"> * As in case of Py_CLEAR &quot;the obvious&quot; code can be deadly:</span>
<a name="859" /><span class="Maybe">     859:</span> <span class="k"> *</span>
<a name="860" /><span class="Maybe">     860:</span> <span class="k"> *     Py_DECREF(op);</span>
<a name="861" /><span class="Maybe">     861:</span> <span class="k"> *     op = op2;</span>
<a name="862" /><span class="Maybe">     862:</span> <span class="k"> *</span>
<a name="863" /><span class="Maybe">     863:</span> <span class="k"> * The safe way is:</span>
<a name="864" /><span class="Maybe">     864:</span> <span class="k"> *</span>
<a name="865" /><span class="Maybe">     865:</span> <span class="k"> *      Py_SETREF(op, op2);</span>
<a name="866" /><span class="Maybe">     866:</span> <span class="k"> *</span>
<a name="867" /><span class="Maybe">     867:</span> <span class="k"> * That arranges to set `op` to `op2` _before_ decref&apos;ing, so that any code</span>
<a name="868" /><span class="Maybe">     868:</span> <span class="k"> * triggered as a side-effect of `op` getting torn down no longer believes</span>
<a name="869" /><span class="Maybe">     869:</span> <span class="k"> * `op` points to a valid object.</span>
<a name="870" /><span class="Maybe">     870:</span> <span class="k"> *</span>
<a name="871" /><span class="Maybe">     871:</span> <span class="k"> * Py_XSETREF is a variant of Py_SETREF that uses Py_XDECREF instead of</span>
<a name="872" /><span class="Maybe">     872:</span> <span class="k"> * Py_DECREF.</span>
<a name="873" /><span class="Maybe">     873:</span> <span class="k"> */</span>
<a name="874" /><span class="Maybe">     874:</span> 
<a name="875" /><span class="Maybe">     875:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfU0VUUkVGXzA_"><span class="b">Py_SETREF</span></a><span class="f">(</span><span class="b">op</span><span class="f">,</span> <span class="b">op2</span><span class="f">)</span>                      \
<a name="876" /><span class="Maybe">     876:</span>     <span class="m">do</span> <span class="f">{</span>                                        \
<a name="877" /><span class="Maybe">     877:</span>         <span class="b">PyObject</span> <span class="f">*</span><span class="b">_py_tmp</span> <span class="f">=</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">;</span>   \
<a name="878" /><span class="Maybe">     878:</span>         <span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">=</span> <span class="f">(</span><span class="b">op2</span><span class="f">)</span><span class="f">;</span>                           \
<a name="879" /><span class="Maybe">     879:</span>         <a href="macros_ref.html#_UHlfREVDUkVGXzA_"><span class="b">Py_DECREF</span></a><span class="f">(</span><span class="b">_py_tmp</span><span class="f">)</span><span class="f">;</span>                     \
<a name="880" /><span class="Maybe">     880:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="881" /><span class="Maybe">     881:</span> 
<a name="882" /><span class="Maybe">     882:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_noref.html#_UHlfWFNFVFJFRl8w"><span class="b">Py_XSETREF</span></a><span class="f">(</span><span class="b">op</span><span class="f">,</span> <span class="b">op2</span><span class="f">)</span>                     \
<a name="883" /><span class="Maybe">     883:</span>     <span class="m">do</span> <span class="f">{</span>                                        \
<a name="884" /><span class="Maybe">     884:</span>         <span class="b">PyObject</span> <span class="f">*</span><span class="b">_py_tmp</span> <span class="f">=</span> <span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">(</span><span class="b">op</span><span class="f">)</span><span class="f">;</span>   \
<a name="885" /><span class="Maybe">     885:</span>         <span class="f">(</span><span class="b">op</span><span class="f">)</span> <span class="f">=</span> <span class="f">(</span><span class="b">op2</span><span class="f">)</span><span class="f">;</span>                           \
<a name="886" /><span class="Maybe">     886:</span>         <a href="macros_ref.html#_UHlfWERFQ1JFRl8w"><span class="b">Py_XDECREF</span></a><span class="f">(</span><span class="b">_py_tmp</span><span class="f">)</span><span class="f">;</span>                    \
<a name="887" /><span class="Maybe">     887:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="888" /><span class="Maybe">     888:</span> 
<a name="889" /><span class="Maybe">     889:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* ifndef Py_LIMITED_API */</span>
<a name="890" /><span class="Maybe">     890:</span> 
<a name="891" /><span class="Maybe">     891:</span> <span class="k">/*</span>
<a name="892" /><span class="Maybe">     892:</span> <span class="k">These are provided as conveniences to Python runtime embedders, so that</span>
<a name="893" /><span class="Maybe">     893:</span> <span class="k">they can have object code that is not dependent on Python compilation flags.</span>
<a name="894" /><span class="Maybe">     894:</span> <span class="k">*/</span>
<a name="895" /><span class="Maybe">     895:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">Py_IncRef</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="896" /><span class="Maybe">     896:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">Py_DecRef</span><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="897" /><span class="Maybe">     897:</span> 
<a name="898" /><span class="Maybe">     898:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="899" /><span class="Maybe">     899:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">PyTypeObject</span><span class="f">)</span> <span class="b">_PyNone_Type</span><span class="f">;</span>
<a name="900" /><span class="Maybe">     900:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">PyTypeObject</span><span class="f">)</span> <span class="b">_PyNotImplemented_Type</span><span class="f">;</span>
<a name="901" /><span class="Maybe">     901:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* !Py_LIMITED_API */</span>
<a name="902" /><span class="Maybe">     902:</span> 
<a name="903" /><span class="Maybe">     903:</span> <span class="k">/*</span>
<a name="904" /><span class="Maybe">     904:</span> <span class="k">_Py_NoneStruct is an object of undefined type which can be used in contexts</span>
<a name="905" /><span class="Maybe">     905:</span> <span class="k">where NULL (nil) is not suitable (since NULL often means &apos;error&apos;).</span>
<a name="906" /><span class="Maybe">     906:</span> <span class="k"></span>
<a name="907" /><span class="Maybe">     907:</span> <span class="k">Don&apos;t forget to apply Py_INCREF() when returning this value!!!</span>
<a name="908" /><span class="Maybe">     908:</span> <span class="k">*/</span>
<a name="909" /><span class="Maybe">     909:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">PyObject</span><span class="f">)</span> <span class="b">_Py_NoneStruct</span><span class="f">;</span> <span class="k">/* Don&apos;t use this directly */</span>
<a name="910" /><span class="Maybe">     910:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfTm9uZV8w"><span class="b">Py_None</span></a> <span class="f">(</span><span class="f">&amp;</span><span class="b">_Py_NoneStruct</span><span class="f">)</span>
<a name="911" /><span class="Maybe">     911:</span> 
<a name="912" /><span class="Maybe">     912:</span> <span class="k">/* Macro for returning Py_None from a function */</span>
<a name="913" /><span class="Maybe">     913:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfUkVUVVJOX05PTkVfMA__"><span class="b">Py_RETURN_NONE</span></a> <span class="m">return</span> <a href="macros_ref.html#_UHlfSU5DUkVGXzA_"><span class="b">Py_INCREF</span></a><span class="f">(</span><a href="macros_ref.html#_UHlfTm9uZV8w"><span class="b">Py_None</span></a><span class="f">)</span><span class="f">,</span> <a href="macros_ref.html#_UHlfTm9uZV8w"><span class="b">Py_None</span></a>
<a name="914" /><span class="Maybe">     914:</span> 
<a name="915" /><span class="Maybe">     915:</span> <span class="k">/*</span>
<a name="916" /><span class="Maybe">     916:</span> <span class="k">Py_NotImplemented is a singleton used to signal that an operation is</span>
<a name="917" /><span class="Maybe">     917:</span> <span class="k">not implemented for a given type combination.</span>
<a name="918" /><span class="Maybe">     918:</span> <span class="k">*/</span>
<a name="919" /><span class="Maybe">     919:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">PyObject</span><span class="f">)</span> <span class="b">_Py_NotImplementedStruct</span><span class="f">;</span> <span class="k">/* Don&apos;t use this directly */</span>
<a name="920" /><span class="Maybe">     920:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfTm90SW1wbGVtZW50ZWRfMA__"><span class="b">Py_NotImplemented</span></a> <span class="f">(</span><span class="f">&amp;</span><span class="b">_Py_NotImplementedStruct</span><span class="f">)</span>
<a name="921" /><span class="Maybe">     921:</span> 
<a name="922" /><span class="Maybe">     922:</span> <span class="k">/* Macro for returning Py_NotImplemented from a function */</span>
<a name="923" /><span class="Maybe">     923:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfUkVUVVJOX05PVElNUExFTUVOVEVEXzA_"><span class="b">Py_RETURN_NOTIMPLEMENTED</span></a> \
<a name="924" /><span class="Maybe">     924:</span>     <span class="m">return</span> <a href="macros_ref.html#_UHlfSU5DUkVGXzA_"><span class="b">Py_INCREF</span></a><span class="f">(</span><a href="macros_ref.html#_UHlfTm90SW1wbGVtZW50ZWRfMA__"><span class="b">Py_NotImplemented</span></a><span class="f">)</span><span class="f">,</span> <a href="macros_ref.html#_UHlfTm90SW1wbGVtZW50ZWRfMA__"><span class="b">Py_NotImplemented</span></a>
<a name="925" /><span class="Maybe">     925:</span> 
<a name="926" /><span class="Maybe">     926:</span> <span class="k">/* Rich comparison opcodes */</span>
<a name="927" /><span class="Maybe">     927:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfTFRfMA__"><span class="b">Py_LT</span></a> <span class="c">0</span>
<a name="928" /><span class="Maybe">     928:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfTEVfMA__"><span class="b">Py_LE</span></a> <span class="c">1</span>
<a name="929" /><span class="Maybe">     929:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfRVFfMA__"><span class="b">Py_EQ</span></a> <span class="c">2</span>
<a name="930" /><span class="Maybe">     930:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfTkVfMA__"><span class="b">Py_NE</span></a> <span class="c">3</span>
<a name="931" /><span class="Maybe">     931:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfR1RfMA__"><span class="b">Py_GT</span></a> <span class="c">4</span>
<a name="932" /><span class="Maybe">     932:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfR0VfMA__"><span class="b">Py_GE</span></a> <span class="c">5</span>
<a name="933" /><span class="Maybe">     933:</span> 
<a name="934" /><span class="Maybe">     934:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="935" /><span class="Maybe">     935:</span> <span class="k">/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE.</span>
<a name="936" /><span class="Maybe">     936:</span> <span class="k"> * Defined in object.c.</span>
<a name="937" /><span class="Maybe">     937:</span> <span class="k"> */</span>
<a name="938" /><span class="Maybe">     938:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">_Py_SwappedOp</span><span class="f">[</span><span class="f">]</span><span class="f">;</span>
<a name="939" /><span class="Maybe">     939:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* !Py_LIMITED_API */</span>
<a name="940" /><span class="Maybe">     940:</span> 
<a name="941" /><span class="Maybe">     941:</span> 
<a name="942" /><span class="Maybe">     942:</span> <span class="k">/*</span>
<a name="943" /><span class="Maybe">     943:</span> <span class="k">More conventions</span>
<a name="944" /><span class="Maybe">     944:</span> <span class="k">================</span>
<a name="945" /><span class="Maybe">     945:</span> <span class="k"></span>
<a name="946" /><span class="Maybe">     946:</span> <span class="k">Argument Checking</span>
<a name="947" /><span class="Maybe">     947:</span> <span class="k">-----------------</span>
<a name="948" /><span class="Maybe">     948:</span> <span class="k"></span>
<a name="949" /><span class="Maybe">     949:</span> <span class="k">Functions that take objects as arguments normally don&apos;t check for nil</span>
<a name="950" /><span class="Maybe">     950:</span> <span class="k">arguments, but they do check the type of the argument, and return an</span>
<a name="951" /><span class="Maybe">     951:</span> <span class="k">error if the function doesn&apos;t apply to the type.</span>
<a name="952" /><span class="Maybe">     952:</span> <span class="k"></span>
<a name="953" /><span class="Maybe">     953:</span> <span class="k">Failure Modes</span>
<a name="954" /><span class="Maybe">     954:</span> <span class="k">-------------</span>
<a name="955" /><span class="Maybe">     955:</span> <span class="k"></span>
<a name="956" /><span class="Maybe">     956:</span> <span class="k">Functions may fail for a variety of reasons, including running out of</span>
<a name="957" /><span class="Maybe">     957:</span> <span class="k">memory.  This is communicated to the caller in two ways: an error string</span>
<a name="958" /><span class="Maybe">     958:</span> <span class="k">is set (see errors.h), and the function result differs: functions that</span>
<a name="959" /><span class="Maybe">     959:</span> <span class="k">normally return a pointer return NULL for failure, functions returning</span>
<a name="960" /><span class="Maybe">     960:</span> <span class="k">an integer return -1 (which could be a legal return value too!), and</span>
<a name="961" /><span class="Maybe">     961:</span> <span class="k">other functions return 0 for success and -1 for failure.</span>
<a name="962" /><span class="Maybe">     962:</span> <span class="k">Callers should always check for errors before using the result.  If</span>
<a name="963" /><span class="Maybe">     963:</span> <span class="k">an error was set, the caller must either explicitly clear it, or pass</span>
<a name="964" /><span class="Maybe">     964:</span> <span class="k">the error on to its caller.</span>
<a name="965" /><span class="Maybe">     965:</span> <span class="k"></span>
<a name="966" /><span class="Maybe">     966:</span> <span class="k">Reference Counts</span>
<a name="967" /><span class="Maybe">     967:</span> <span class="k">----------------</span>
<a name="968" /><span class="Maybe">     968:</span> <span class="k"></span>
<a name="969" /><span class="Maybe">     969:</span> <span class="k">It takes a while to get used to the proper usage of reference counts.</span>
<a name="970" /><span class="Maybe">     970:</span> <span class="k"></span>
<a name="971" /><span class="Maybe">     971:</span> <span class="k">Functions that create an object set the reference count to 1; such new</span>
<a name="972" /><span class="Maybe">     972:</span> <span class="k">objects must be stored somewhere or destroyed again with Py_DECREF().</span>
<a name="973" /><span class="Maybe">     973:</span> <span class="k">Some functions that &apos;store&apos; objects, such as PyTuple_SetItem() and</span>
<a name="974" /><span class="Maybe">     974:</span> <span class="k">PyList_SetItem(),</span>
<a name="975" /><span class="Maybe">     975:</span> <span class="k">don&apos;t increment the reference count of the object, since the most</span>
<a name="976" /><span class="Maybe">     976:</span> <span class="k">frequent use is to store a fresh object.  Functions that &apos;retrieve&apos;</span>
<a name="977" /><span class="Maybe">     977:</span> <span class="k">objects, such as PyTuple_GetItem() and PyDict_GetItemString(), also</span>
<a name="978" /><span class="Maybe">     978:</span> <span class="k">don&apos;t increment</span>
<a name="979" /><span class="Maybe">     979:</span> <span class="k">the reference count, since most frequently the object is only looked at</span>
<a name="980" /><span class="Maybe">     980:</span> <span class="k">quickly.  Thus, to retrieve an object and store it again, the caller</span>
<a name="981" /><span class="Maybe">     981:</span> <span class="k">must call Py_INCREF() explicitly.</span>
<a name="982" /><span class="Maybe">     982:</span> <span class="k"></span>
<a name="983" /><span class="Maybe">     983:</span> <span class="k">NOTE: functions that &apos;consume&apos; a reference count, like</span>
<a name="984" /><span class="Maybe">     984:</span> <span class="k">PyList_SetItem(), consume the reference even if the object wasn&apos;t</span>
<a name="985" /><span class="Maybe">     985:</span> <span class="k">successfully stored, to simplify error handling.</span>
<a name="986" /><span class="Maybe">     986:</span> <span class="k"></span>
<a name="987" /><span class="Maybe">     987:</span> <span class="k">It seems attractive to make other functions that take an object as</span>
<a name="988" /><span class="Maybe">     988:</span> <span class="k">argument consume a reference count; however, this may quickly get</span>
<a name="989" /><span class="Maybe">     989:</span> <span class="k">confusing (even the current practice is already confusing).  Consider</span>
<a name="990" /><span class="Maybe">     990:</span> <span class="k">it carefully, it may save lots of calls to Py_INCREF() and Py_DECREF() at</span>
<a name="991" /><span class="Maybe">     991:</span> <span class="k">times.</span>
<a name="992" /><span class="Maybe">     992:</span> <span class="k">*/</span>
<a name="993" /><span class="Maybe">     993:</span> 
<a name="994" /><span class="Maybe">     994:</span> 
<a name="995" /><span class="Maybe">     995:</span> <span class="k">/* Trashcan mechanism, thanks to Christian Tismer.</span>
<a name="996" /><span class="Maybe">     996:</span> <span class="k"></span>
<a name="997" /><span class="Maybe">     997:</span> <span class="k">When deallocating a container object, it&apos;s possible to trigger an unbounded</span>
<a name="998" /><span class="Maybe">     998:</span> <span class="k">chain of deallocations, as each Py_DECREF in turn drops the refcount on &quot;the</span>
<a name="999" /><span class="Maybe">     999:</span> <span class="k">next&quot; object in the chain to 0.  This can easily lead to stack faults, and</span>
<a name="1000" /><span class="Maybe">    1000:</span> <span class="k">especially in threads (which typically have less stack space to work with).</span>
<a name="1001" /><span class="Maybe">    1001:</span> <span class="k"></span>
<a name="1002" /><span class="Maybe">    1002:</span> <span class="k">A container object that participates in cyclic gc can avoid this by</span>
<a name="1003" /><span class="Maybe">    1003:</span> <span class="k">bracketing the body of its tp_dealloc function with a pair of macros:</span>
<a name="1004" /><span class="Maybe">    1004:</span> <span class="k"></span>
<a name="1005" /><span class="Maybe">    1005:</span> <span class="k">static void</span>
<a name="1006" /><span class="Maybe">    1006:</span> <span class="k">mytype_dealloc(mytype *p)</span>
<a name="1007" /><span class="Maybe">    1007:</span> <span class="k">{</span>
<a name="1008" /><span class="Maybe">    1008:</span> <span class="k">    ... declarations go here ...</span>
<a name="1009" /><span class="Maybe">    1009:</span> <span class="k"></span>
<a name="1010" /><span class="Maybe">    1010:</span> <span class="k">    PyObject_GC_UnTrack(p);        // must untrack first</span>
<a name="1011" /><span class="Maybe">    1011:</span> <span class="k">    Py_TRASHCAN_SAFE_BEGIN(p)</span>
<a name="1012" /><span class="Maybe">    1012:</span> <span class="k">    ... The body of the deallocator goes here, including all calls ...</span>
<a name="1013" /><span class="Maybe">    1013:</span> <span class="k">    ... to Py_DECREF on contained objects.                         ...</span>
<a name="1014" /><span class="Maybe">    1014:</span> <span class="k">    Py_TRASHCAN_SAFE_END(p)</span>
<a name="1015" /><span class="Maybe">    1015:</span> <span class="k">}</span>
<a name="1016" /><span class="Maybe">    1016:</span> <span class="k"></span>
<a name="1017" /><span class="Maybe">    1017:</span> <span class="k">CAUTION:  Never return from the middle of the body!  If the body needs to</span>
<a name="1018" /><span class="Maybe">    1018:</span> <span class="k">&quot;get out early&quot;, put a label immediately before the Py_TRASHCAN_SAFE_END</span>
<a name="1019" /><span class="Maybe">    1019:</span> <span class="k">call, and goto it.  Else the call-depth counter (see below) will stay</span>
<a name="1020" /><span class="Maybe">    1020:</span> <span class="k">above 0 forever, and the trashcan will never get emptied.</span>
<a name="1021" /><span class="Maybe">    1021:</span> <span class="k"></span>
<a name="1022" /><span class="Maybe">    1022:</span> <span class="k">How it works:  The BEGIN macro increments a call-depth counter.  So long</span>
<a name="1023" /><span class="Maybe">    1023:</span> <span class="k">as this counter is small, the body of the deallocator is run directly without</span>
<a name="1024" /><span class="Maybe">    1024:</span> <span class="k">further ado.  But if the counter gets large, it instead adds p to a list of</span>
<a name="1025" /><span class="Maybe">    1025:</span> <span class="k">objects to be deallocated later, skips the body of the deallocator, and</span>
<a name="1026" /><span class="Maybe">    1026:</span> <span class="k">resumes execution after the END macro.  The tp_dealloc routine then returns</span>
<a name="1027" /><span class="Maybe">    1027:</span> <span class="k">without deallocating anything (and so unbounded call-stack depth is avoided).</span>
<a name="1028" /><span class="Maybe">    1028:</span> <span class="k"></span>
<a name="1029" /><span class="Maybe">    1029:</span> <span class="k">When the call stack finishes unwinding again, code generated by the END macro</span>
<a name="1030" /><span class="Maybe">    1030:</span> <span class="k">notices this, and calls another routine to deallocate all the objects that</span>
<a name="1031" /><span class="Maybe">    1031:</span> <span class="k">may have been added to the list of deferred deallocations.  In effect, a</span>
<a name="1032" /><span class="Maybe">    1032:</span> <span class="k">chain of N deallocations is broken into N / PyTrash_UNWIND_LEVEL pieces,</span>
<a name="1033" /><span class="Maybe">    1033:</span> <span class="k">with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL.</span>
<a name="1034" /><span class="Maybe">    1034:</span> <span class="k">*/</span>
<a name="1035" /><span class="Maybe">    1035:</span> 
<a name="1036" /><span class="Maybe">    1036:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="1037" /><span class="Maybe">    1037:</span> <span class="k">/* This is the old private API, invoked by the macros before 3.2.4.</span>
<a name="1038" /><span class="Maybe">    1038:</span> <span class="k">   Kept for binary compatibility of extensions using the stable ABI. */</span>
<a name="1039" /><span class="Maybe">    1039:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_PyTrash_deposit_object</span><span class="f">(</span><span class="b">PyObject</span><span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="1040" /><span class="Maybe">    1040:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_PyTrash_destroy_chain</span><span class="f">(</span><span class="m">void</span><span class="f">)</span><span class="f">;</span>
<a name="1041" /><span class="Maybe">    1041:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="m">int</span><span class="f">)</span> <span class="b">_PyTrash_delete_nesting</span><span class="f">;</span>
<a name="1042" /><span class="Maybe">    1042:</span> <a href="macros_ref.html#_UHlBUElfREFUQV8w"><span class="b">PyAPI_DATA</span></a><span class="f">(</span><span class="b">PyObject</span> <span class="f">*</span><span class="f">)</span> <span class="b">_PyTrash_delete_later</span><span class="f">;</span>
<a name="1043" /><span class="Maybe">    1043:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* !Py_LIMITED_API */</span>
<a name="1044" /><span class="Maybe">    1044:</span> 
<a name="1045" /><span class="Maybe">    1045:</span> <span class="k">/* The new thread-safe private API, invoked by the macros below. */</span>
<a name="1046" /><span class="Maybe">    1046:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_PyTrash_thread_deposit_object</span><span class="f">(</span><span class="b">PyObject</span><span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="1047" /><span class="Maybe">    1047:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span> <span class="b">_PyTrash_thread_destroy_chain</span><span class="f">(</span><span class="m">void</span><span class="f">)</span><span class="f">;</span>
<a name="1048" /><span class="Maybe">    1048:</span> 
<a name="1049" /><span class="Maybe">    1049:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlUcmFzaF9VTldJTkRfTEVWRUxfMA__"><span class="b">PyTrash_UNWIND_LEVEL</span></a> <span class="c">50</span>
<a name="1050" /><span class="Maybe">    1050:</span> 
<a name="1051" /><span class="Maybe">    1051:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFJBU0hDQU5fU0FGRV9CRUdJTl8w"><span class="b">Py_TRASHCAN_SAFE_BEGIN</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> \
<a name="1052" /><span class="Maybe">    1052:</span>     <span class="m">do</span> <span class="f">{</span> \
<a name="1053" /><span class="Maybe">    1053:</span>         <span class="b">PyThreadState</span> <span class="f">*</span><span class="b">_tstate</span> <span class="f">=</span> <a href="macros_ref.html#_UHlUaHJlYWRTdGF0ZV9HRVRfMA__"><span class="b">PyThreadState_GET</span></a><span class="f">(</span><span class="f">)</span><span class="f">;</span> \
<a name="1054" /><span class="Maybe">    1054:</span>         <span class="m">if</span> <span class="f">(</span><span class="b">_tstate</span><span class="f">-&gt;</span><span class="b">trash_delete_nesting</span> <span class="f">&lt;</span> <a href="macros_ref.html#_UHlUcmFzaF9VTldJTkRfTEVWRUxfMA__"><span class="b">PyTrash_UNWIND_LEVEL</span></a><span class="f">)</span> <span class="f">{</span> \
<a name="1055" /><span class="Maybe">    1055:</span>             <span class="f">++</span><span class="b">_tstate</span><span class="f">-&gt;</span><span class="b">trash_delete_nesting</span><span class="f">;</span>
<a name="1056" /><span class="Maybe">    1056:</span>             <span class="k">/* The body of the deallocator is here. */</span>
<a name="1057" /><span class="Maybe">    1057:</span> <span class="f">#</span><span class="n">define</span> <a href="macros_ref.html#_UHlfVFJBU0hDQU5fU0FGRV9FTkRfMA__"><span class="b">Py_TRASHCAN_SAFE_END</span></a><span class="f">(</span><span class="b">op</span><span class="f">)</span> \
<a name="1058" /><span class="Maybe">    1058:</span>             <span class="f">--</span><span class="b">_tstate</span><span class="f">-&gt;</span><span class="b">trash_delete_nesting</span><span class="f">;</span> \
<a name="1059" /><span class="Maybe">    1059:</span>             <span class="m">if</span> <span class="f">(</span><span class="b">_tstate</span><span class="f">-&gt;</span><span class="b">trash_delete_later</span> <span class="f">&amp;&amp;</span> <span class="b">_tstate</span><span class="f">-&gt;</span><span class="b">trash_delete_nesting</span> <span class="f">&lt;=</span> <span class="c">0</span><span class="f">)</span> \
<a name="1060" /><span class="Maybe">    1060:</span>                 <span class="b">_PyTrash_thread_destroy_chain</span><span class="f">(</span><span class="f">)</span><span class="f">;</span> \
<a name="1061" /><span class="Maybe">    1061:</span>         <span class="f">}</span> \
<a name="1062" /><span class="Maybe">    1062:</span>         <span class="m">else</span> \
<a name="1063" /><span class="Maybe">    1063:</span>             <span class="b">_PyTrash_thread_deposit_object</span><span class="f">(</span><span class="f">(</span><span class="b">PyObject</span><span class="f">*</span><span class="f">)</span><span class="b">op</span><span class="f">)</span><span class="f">;</span> \
<a name="1064" /><span class="Maybe">    1064:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span><span class="f">;</span>
<a name="1065" /><span class="Maybe">    1065:</span> 
<a name="1066" /><span class="Maybe">    1066:</span> <span class="f">#</span><span class="n">ifndef</span> <span class="b">Py_LIMITED_API</span>
<a name="1067" /><span class="Maybe">    1067:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span>
<a name="1068" /><span class="Maybe">    1068:</span> <span class="b">_PyDebugAllocatorStats</span><span class="f">(</span><span class="b">FILE</span> <span class="f">*</span><span class="b">out</span><span class="f">,</span> <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="b">block_name</span><span class="f">,</span> <span class="m">int</span> <span class="b">num_blocks</span><span class="f">,</span>
<a name="1069" /><span class="Maybe">    1069:</span>                        <span class="b">size_t</span> <span class="b">sizeof_block</span><span class="f">)</span><span class="f">;</span>
<a name="1070" /><span class="Maybe">    1070:</span> <a href="macros_ref.html#_UHlBUElfRlVOQ18w"><span class="b">PyAPI_FUNC</span></a><span class="f">(</span><span class="m">void</span><span class="f">)</span>
<a name="1071" /><span class="Maybe">    1071:</span> <span class="b">_PyObject_DebugTypeStats</span><span class="f">(</span><span class="b">FILE</span> <span class="f">*</span><span class="b">out</span><span class="f">)</span><span class="f">;</span>
<a name="1072" /><span class="Maybe">    1072:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* ifndef Py_LIMITED_API */</span>
<a name="1073" /><span class="Maybe">    1073:</span> 
<a name="1074" /><span class="False">    1074:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">__cplusplus</span>
<a name="1075" /><span class="False">    1075:</span> <span class="f">}</span>
<a name="1076" /><span class="Maybe">    1076:</span> <span class="f">#</span><span class="n">endif</span>
<a name="1077" /><span class="True">    1077:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* !Py_OBJECT_H */</span>
<a name="1078" /><span class="True">    1078:</span> </pre>
  </body>
</html>
